@salesforce/lds-runtime-aura 1.320.0 → 1.322.0

package/dist/ldsEngineCreator.js

@@ -73,7 +73,7 @@ class NetworkCommand extends BaseCommand {
         return this.fetch();
     }
 }
-function buildServiceDescriptor$9() {
+function buildServiceDescriptor$a() {
     return {
         type: 'networkCommandBaseClass',
         version: '1.0',
@@ -88,6 +88,10 @@ function buildServiceDescriptor$9() {
  */
 
 
+const { create: create$1, freeze, keys: keys$1 } = Object;
+const { isArray: isArray$1 } = Array;
+const { stringify: stringify$1 } = JSON;
+
 const LogLevelMap$1 = {
     TRACE: 4,
     DEBUG: 3,
@@ -215,6 +219,61 @@ function rejectedPromiseLike(reason) {
 function isPromiseLike(x) {
     return typeof x === 'object' && typeof (x === null || x === void 0 ? void 0 : x.then) === 'function';
 }
+/**
+ * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+ * This is needed because insertion order for JSON.stringify(object) affects output:
+ * JSON.stringify({a: 1, b: 2})
+ *      "{"a":1,"b":2}"
+ * JSON.stringify({b: 2, a: 1})
+ *      "{"b":2,"a":1}"
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+function stableJSONStringify$2(node) {
+    // This is for Date values.
+    if (node && node.toJSON && typeof node.toJSON === 'function') {
+        // eslint-disable-next-line no-param-reassign
+        node = node.toJSON();
+    }
+    if (node === undefined) {
+        return;
+    }
+    if (typeof node === 'number') {
+        return isFinite(node) ? '' + node : 'null';
+    }
+    if (typeof node !== 'object') {
+        return stringify$1(node);
+    }
+    let i;
+    let out;
+    if (isArray$1(node)) {
+        out = '[';
+        for (i = 0; i < node.length; i++) {
+            if (i) {
+                out += ',';
+            }
+            out += stableJSONStringify$2(node[i]) || 'null';
+        }
+        return out + ']';
+    }
+    if (node === null) {
+        return 'null';
+    }
+    const objKeys = keys$1(node).sort();
+    out = '';
+    for (i = 0; i < objKeys.length; i++) {
+        const key = objKeys[i];
+        const value = stableJSONStringify$2(node[key]);
+        if (!value) {
+            continue;
+        }
+        if (out) {
+            out += ',';
+        }
+        out += stringify$1(key) + ':' + value;
+    }
+    return '{' + out + '}';
+}
 /**
  * Converts an arbitrary value to an Error.
  *
@@ -271,7 +330,7 @@ class AuraNetworkCommand extends NetworkCommand {
     }
 }
 
-function buildServiceDescriptor$8() {
+function buildServiceDescriptor$9() {
     return {
         type: 'auraNetworkCommandBaseClass',
         version: '1.0',
@@ -286,6 +345,116 @@ function buildServiceDescriptor$8() {
  */
 
 
+/**
+ * An implementation of BaseCommand that allows for extending abstract cache methods
+ *
+ * @typeParam Data cache result for read operations
+ * @typeParam NetworkResult cache result including network metadata
+ * @typeParam ExtraServices additional named services needed by a subclass
+ */
+class CacheControlCommand extends BaseCommand {
+    constructor(services) {
+        super();
+        this.services = services;
+    }
+    execute() {
+        return this.services.cacheController.execute(this.cacheControlStrategyConfig, (cache) => this.buildRequestRunner(cache));
+    }
+    buildRequestRunner(cache) {
+        return {
+            readFromCache: () => this.readFromCache(cache),
+            requestFromNetwork: () => this.requestFromNetwork(),
+            writeToCache: (networkResult) => this.writeToCache(cache, networkResult),
+        };
+    }
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of BaseCommand that allows for extending abstract cache methods
+ *
+ * @typeParam Data cache result for read operations
+ * @typeParam NetworkResult cache result including network metadata
+ * @typeParam ExtraServices additional named services needed by a subclass
+ */
+class AuraResourceCacheControlCommand extends CacheControlCommand {
+    constructor(services) {
+        super(services);
+        this.services = services;
+        this.actionConfig = {
+            background: false,
+            hotspot: true,
+            longRunning: false,
+            storable: false,
+        };
+    }
+    execute() {
+        return super.execute();
+    }
+    readFromCache(cache) {
+        var _a;
+        return resolvedPromiseLike(ok((_a = cache.get(this.buildKey())) === null || _a === void 0 ? void 0 : _a.value));
+    }
+    requestFromNetwork() {
+        return this.convertAuraResponseToData(this.services.auraNetwork(this.endpoint, this.auraParams, this.actionConfig));
+    }
+    convertAuraResponseToData(responsePromise) {
+        return responsePromise
+            .then((response) => {
+            return ok(response.getReturnValue());
+        })
+            .catch((error) => {
+            if (!error || !error.getError) {
+                return err(toError('Failed to get error from response'));
+            }
+            const actionErrors = error.getError();
+            if (actionErrors.length > 0) {
+                return err(new AuraError(actionErrors));
+            }
+            return err(toError('Error fetching component'));
+        });
+    }
+    writeToCache(cache, networkResult) {
+        if (networkResult.isOk()) {
+            cache.set(this.buildKey(), {
+                value: networkResult.value,
+                metadata: { cacheControl: this.buildCacheControlMetadata(networkResult.value) },
+            });
+        }
+        return resolvedPromiseLike(undefined);
+    }
+    buildKey() {
+        return `{"endpoint":${this.endpoint},"params":${stableJSONStringify$2(this.auraParams)}}`;
+    }
+}
+class AuraError extends Error {
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+}
+
+function buildServiceDescriptor$8() {
+    return {
+        type: 'auraResourceCacheControlCommand',
+        version: '1.0',
+        service: AuraResourceCacheControlCommand,
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
 /**
  * An implementation of NetworkCommand that uses HTTP/fetch as the transport mechanism.
  */
@@ -1040,7 +1209,7 @@ class CacheController {
 
 function buildServiceDescriptor$1(cache) {
     return {
-        type: 'cacheControl',
+        type: 'cacheController',
         version: '1.0',
         service: new CacheController({ cache }),
     };
@@ -1550,9 +1719,9 @@ const composedNetworkAdapter$1 = {
 function e(e){this.message=e;}e.prototype=new Error,e.prototype.name="InvalidCharacterError";"undefined"!=typeof window&&window.atob&&window.atob.bind(window)||function(r){var t=String(r).replace(/=+$/,"");if(t.length%4==1)throw new e("'atob' failed: The string to be decoded is not correctly encoded.");for(var n,o,a=0,i=0,c="";o=t.charAt(i++);~o&&(n=a%4?64*n+o:o,a++%4)?c+=String.fromCharCode(255&n>>(-2*a&6)):0)o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(o);return c};function n(e){this.message=e;}n.prototype=new Error,n.prototype.name="InvalidTokenError";
 
 const SFAP_BASE_URL = 'api.salesforce.com';
+const sfapJwtRepository = new JwtRepository();
+const sfapJwtManager = new JwtManager(sfapJwtRepository, platformSfapJwtResolver);
 function buildJwtAuthorizedSfapFetchServiceDescriptor(logger) {
-    const jwtRepository = new JwtRepository();
-    const jwtManager = new JwtManager(jwtRepository, platformSfapJwtResolver);
     const jwtRequestModifier = ({ baseUri }, [resource, request]) => {
         if (typeof resource !== 'string' && !(resource instanceof URL)) {
             // istanbul ignore else: this will not be tested in NODE_ENV = production for test coverage
@@ -1571,7 +1740,7 @@ function buildJwtAuthorizedSfapFetchServiceDescriptor(logger) {
         url.protocol = overrideUrl.protocol;
         return [url, request];
     };
-    const jwtRequestHeaderInterceptor = buildJwtRequestHeaderInterceptor(jwtManager, jwtRequestModifier);
+    const jwtRequestHeaderInterceptor = buildJwtRequestHeaderInterceptor(sfapJwtManager, jwtRequestModifier);
     const jwtAuthorizedFetchService = buildServiceDescriptor({
         request: [jwtRequestHeaderInterceptor],
     });
@@ -1580,6 +1749,56 @@ function buildJwtAuthorizedSfapFetchServiceDescriptor(logger) {
         tags: { authenticationScopes: 'sfap_api' },
     };
 }
+/**
+ * Returns a service descriptor for a fetch service that includes one-off copilot
+ * hacks. This fetch service is not intended for use by anything other than
+ * copilot commands.
+ */
+function buildCopilotFetchServiceDescriptor(logger) {
+    return {
+        // Note that this layers the Interceptor below directly on top of fetch(). WHen
+        // we switch to JWT authentication this will need to change to incorporate the
+        // Interceptor here with the logic in buildJwtAuthorizedSfapFetchServiceDescriptor()
+        // above.
+        ...buildServiceDescriptor({
+            request: [
+                // Note that this function is VERY closely tied to the fetchParams generated
+                // by copilotStartSessionCommand. Any changes to those parameters will require
+                // corresponding updates to the logic below.
+                (args) => {
+                    const [url, requestInit] = args;
+                    // ignore anything other than a start session request
+                    if (typeof url !== 'string' ||
+                        !url.endsWith('/sessions') ||
+                        !requestInit ||
+                        requestInit.method !== 'POST' ||
+                        !requestInit.body ||
+                        typeof requestInit.body !== 'string') {
+                        return resolvedPromiseLike(args);
+                    }
+                    return resolvedPromiseLike(sfapJwtManager.getJwt()).then((token) => {
+                        // replace the body's instanceConfig.endpoint with the JWT's iss value
+                        const body = JSON.parse(requestInit.body);
+                        if (!body || !body.instanceConfig || !token.decodedInfo.iss) {
+                            logger.warn('skipping injection of endpoint into start session request');
+                        }
+                        else {
+                            body.instanceConfig.endpoint = token.decodedInfo.iss;
+                        }
+                        return [
+                            args[0],
+                            {
+                                ...args[1],
+                                body: JSON.stringify(body),
+                            },
+                        ];
+                    });
+                },
+            ],
+        }),
+        tags: { specialHacksFor: 'copilot' },
+    };
+}
 function buildUnauthorizedFetchServiceDescriptor() {
     const fetchService = buildServiceDescriptor();
     return {
@@ -1594,21 +1813,27 @@ const PDL_EXECUTE_ASYNC_OPTIONS = {
 };
 
 class PredictivePrefetchPage {
-    constructor(context) {
+    constructor(context, similarContext) {
         this.context = context;
-        this.similarContext = undefined;
+        this.similarContext = similarContext;
+    }
+    getExactKey() {
+        return { ...this.context };
+    }
+    getSimilarKey() {
+        return { ...this.similarContext };
     }
 }
 
 class LexDefaultPage extends PredictivePrefetchPage {
-    constructor(context) {
-        super(context);
+    constructor(context, similarContext) {
+        super(context, similarContext);
     }
     supportsRequest(_request) {
         return true;
     }
     buildSaveRequestData(request) {
-        return [{ context: this.context, request }];
+        return [{ key: this.getExactKey(), request }];
     }
     resolveSimilarRequest(similarRequest) {
         return similarRequest;
@@ -2379,6 +2604,15 @@ class GetRelatedListInfoBatchRequestStrategy extends LuvioAdapterRequestStrategy
             },
         };
     }
+    isContextDependent(context, request) {
+        // We have a higher degree of confidence of being able to use a similar request when
+        // optional config is not set AND the object type of the page context is the same as the
+        // object type related list is for.  This approach is based heavily with early predictions
+        // and the max of 12 aura requests in mind.  Same approach is taken in the single version of
+        // this request
+        return (context.objectApiName === request.config.parentObjectApiName &&
+            request.config.recordTypeId === undefined);
+    }
     canCombine(reqA, reqB) {
         return reqA.parentObjectApiName === reqB.parentObjectApiName;
     }
@@ -2400,9 +2634,11 @@ class GetRelatedListInfoRequestStrategy extends LuvioAdapterRequestStrategy {
      * @override
      */
     isContextDependent(context, request) {
-        // we have a higher degree of confidence of being able to use a similar request when
+        // We have a higher degree of confidence of being able to use a similar request when
         // optional config is not set AND the object type of the page context is the same as the
-        // object type related list is for
+        // object type related list is for.  This approach is based heavily with early predictions
+        // and the max of 12 aura requests in mind.  Same approach is taken in the batch version of
+        // this request
         return (context.objectApiName === request.config.parentObjectApiName &&
             this.isRequiredOnlyConfig(request.config));
     }
@@ -2597,10 +2833,13 @@ class PrefetchRepository {
                     existingRequestEntry.requestMetadata.requestTime = requestTime;
                 }
             });
-            const { modifyBeforeSaveHook } = this.options;
+            const { modifyBeforeSaveHook, modifyPageBeforeSavingHook } = this.options;
             if (modifyBeforeSaveHook !== undefined) {
                 page.requests = modifyBeforeSaveHook(page.requests);
             }
+            if (modifyPageBeforeSavingHook !== undefined) {
+                modifyPageBeforeSavingHook(page);
+            }
             setPromises.push(this.storage.set(id, page));
         }
         this.clearRequestBuffer();
@@ -2619,10 +2858,13 @@ class PrefetchRepository {
         this.requestBuffer.set(identifier, batchForKey);
     }
     getPage(key) {
-        const identifier = stableJSONStringify$1(key);
+        const identifier = this.getKeyId(key);
         return this.storage.get(identifier);
     }
     getPageRequests(key) {
+        if (!key) {
+            return [];
+        }
         const page = this.getPage(key);
         if (page === undefined) {
             return [];
@@ -2920,21 +3162,23 @@ const RECORD_HOME_SUPPORTED_ADAPTERS = new Set([
     GET_RELATED_LIST_RECORDS_BATCH_ADAPTER_NAME,
     GET_RELATED_LIST_RECORDS_ADAPTER_NAME,
     GET_RELATED_LISTS_ACTIONS_ADAPTER_NAME,
+    'templateApi', // external - getTemplateDescriptorWithExpansionBundle
 ]);
 class RecordHomePage extends LexDefaultPage {
     constructor(context, requestStrategyManager, options) {
-        super(context);
+        super(context, {
+            ...context,
+            recordId: '*',
+        });
         this.requestStrategyManager = requestStrategyManager;
         this.options = options;
-        const { recordId: _, ...rest } = this.context;
-        this.similarContext = {
-            recordId: '*',
-            ...rest,
-        };
     }
     supportsRequest(request) {
         return RECORD_HOME_SUPPORTED_ADAPTERS.has(request.adapterName);
     }
+    getExactKey() {
+        return RecordHomePage.contextToExactKey(this.context);
+    }
     buildSaveRequestData(request) {
         const requestBuckets = [];
         const { adapterName } = request;
@@ -2944,7 +3188,7 @@ class RecordHomePage extends LexDefaultPage {
         }
         if (matchingRequestStrategy.isContextDependent(this.context, request)) {
             requestBuckets.push({
-                context: this.similarContext,
+                key: this.getSimilarKey(),
                 request: matchingRequestStrategy.transformForSaveSimilarRequest(request),
             });
             // When `options.useExactMatchesPlus` is not enabled, we can save this request on the similar bucket only
@@ -2954,7 +3198,7 @@ class RecordHomePage extends LexDefaultPage {
         }
         if (!matchingRequestStrategy.onlySavedInSimilar) {
             requestBuckets.push({
-                context: this.context,
+                key: this.getExactKey(),
                 request: matchingRequestStrategy.transformForSave(request),
             });
         }
@@ -3005,6 +3249,10 @@ class RecordHomePage extends LexDefaultPage {
             context.recordId !== undefined &&
             context.type === 'recordPage');
     }
+    static contextToExactKey(context) {
+        const { recordTypeId: _, ...key } = context;
+        return key;
+    }
 }
 
 const OBJECT_HOME_SUPPORTED_ADAPTERS = new Set([
@@ -3016,10 +3264,9 @@ const OBJECT_HOME_SUPPORTED_ADAPTERS = new Set([
 ]);
 class ObjectHomePage extends LexDefaultPage {
     constructor(context, requestStrategyManager, options) {
-        super(context);
+        super(context, context);
         this.requestStrategyManager = requestStrategyManager;
         this.options = options;
-        this.similarContext = context;
     }
     supportsRequest(request) {
         return OBJECT_HOME_SUPPORTED_ADAPTERS.has(request.adapterName);
@@ -3033,7 +3280,7 @@ class ObjectHomePage extends LexDefaultPage {
         }
         if (matchingRequestStrategy.isContextDependent(this.context, request)) {
             requestBuckets.push({
-                context: this.similarContext,
+                key: this.getSimilarKey(),
                 request: matchingRequestStrategy.transformForSaveSimilarRequest(request),
             });
             // When `options.useExactMatchesPlus` is not enabled, we can save this request on the similar bucket only
@@ -3042,7 +3289,7 @@ class ObjectHomePage extends LexDefaultPage {
             }
         }
         requestBuckets.push({
-            context: this.context,
+            key: this.getExactKey(),
             request: matchingRequestStrategy.transformForSave(request),
         });
         return requestBuckets;
@@ -3721,10 +3968,10 @@ class ApplicationPredictivePrefetcher {
             if (this.page.supportsRequest(request)) {
                 const saveBuckets = this.page.buildSaveRequestData(request);
                 saveBuckets.forEach((saveBucket) => {
-                    const { request: requestToSave, context } = saveBucket;
+                    const { request: requestToSave, key } = saveBucket;
                     // No need to differentiate from predictions requests because these
                     // are made from the adapters factory, which are not prediction aware.
-                    this.repository.saveRequest(context, requestToSave);
+                    this.repository.saveRequest(key, requestToSave);
                 });
             }
             return Promise.resolve().then();
@@ -3732,8 +3979,8 @@ class ApplicationPredictivePrefetcher {
     }
     async predict() {
         const alwaysRequests = this.page.getAlwaysRunRequests();
-        const similarPageRequests = await this.getSimilarPageRequests();
-        const exactPageRequests = await this.getExactPageRequest();
+        const similarPageRequests = this.getSimilarPageRequests();
+        const exactPageRequests = this.getExactPageRequests();
         // Always requests can't be reduced in - Some of them are essential to keep the page rendering at the beginning.
         const reducedRequests = this.requestRunner
             .reduceRequests([...exactPageRequests, ...similarPageRequests])
@@ -3744,13 +3991,9 @@ class ApplicationPredictivePrefetcher {
         return Promise.all(predictedRequests.map((request) => this.requestRunner.runRequest(request))).then();
     }
     getPredictionSummary() {
-        const exactPageRequests = this.repository.getPageRequests(this.context) || [];
-        const similarPageRequests = this.page.similarContext !== undefined
-            ? this.repository.getPageRequests(this.page.similarContext)
-            : [];
         return {
-            exact: exactPageRequests.length,
-            similar: similarPageRequests.length,
+            exact: this.getExactPageRequests().length,
+            similar: this.getSimilarPageRequests().length,
             totalRequestCount: this.totalRequestCount,
         };
     }
@@ -3759,22 +4002,15 @@ class ApplicationPredictivePrefetcher {
         return summary.exact > 0 || summary.similar > 0;
     }
     getSimilarPageRequests() {
-        let resolvedSimilarPageRequests = [];
-        if (this.page.similarContext !== undefined) {
-            const similarPageRequests = this.repository.getPageRequests(this.page.similarContext);
-            if (similarPageRequests !== undefined) {
-                resolvedSimilarPageRequests = similarPageRequests.map((entry) => {
-                    return {
-                        ...entry,
-                        request: this.page.resolveSimilarRequest(entry.request),
-                    };
-                });
-            }
-        }
-        return resolvedSimilarPageRequests;
+        return this.repository.getPageRequests(this.page.getSimilarKey()).map((entry) => {
+            return {
+                ...entry,
+                request: this.page.resolveSimilarRequest(entry.request),
+            };
+        });
     }
-    getExactPageRequest() {
-        return this.repository.getPageRequests(this.context) || [];
+    getExactPageRequests() {
+        return this.repository.getPageRequests(this.page.getExactKey()) || [];
     }
 }
 
@@ -3838,6 +4074,7 @@ function predictNonBoxcarableRequest(nonBoxcaredPredictions, requestRunner) {
     const reducedPredictions = requestRunner.reduceRequests(nonBoxcaredPredictions);
     reducedPredictions.map((request) => requestRunner.runRequest(request.request));
 }
+const DEFAULT_RECORD_TYPE_ID = '012000000000000AAA';
 class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
     constructor(context, repository, requestRunner, 
     // These strategies need to be in sync with the "predictiveDataLoadCapable" list
@@ -3850,6 +4087,17 @@ class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
     }
     getPage() {
         if (RecordHomePage.handlesContext(this.context)) {
+            /*
+             * `recordTypeId` is required in order to create similar request keys.  However, the means by which it is
+             * obtained varies based on when in the app lifecycle predictions are requested.
+             */
+            // check context for record type
+            if (!this.context.recordTypeId) {
+                // don't have it (i.e., early predictions), so need try to obtain via exact matches
+                const exact = this.repository.getPage(RecordHomePage.contextToExactKey(this.context));
+                // use found recordTypeId, otherwise fallback to default
+                this.context.recordTypeId = (exact && exact.recordTypeId) || DEFAULT_RECORD_TYPE_ID;
+            }
             return new RecordHomePage(this.context, this.requestStrategyManager, this.options);
         }
         else if (ObjectHomePage.handlesContext(this.context)) {
@@ -3858,7 +4106,7 @@ class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
         return new LexDefaultPage(this.context);
     }
     getAllPageRequests() {
-        const exactPageRequests = this.getExactPageRequest();
+        const exactPageRequests = this.getExactPageRequests();
         let similarPageRequests = this.getSimilarPageRequests();
         if (exactPageRequests.length > 0 && this.options.useExactMatchesPlus === true) {
             similarPageRequests = similarPageRequests.filter((requestEntry) => {
@@ -3871,7 +4119,7 @@ class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
     async predict() {
         const alwaysRequests = this.page.getAlwaysRunRequests();
         const pageRequests = this.getAllPageRequests();
-        // IMPORTANT: Because there's no way to diferentiate a cmpDef prediction from the page
+        // IMPORTANT: Because there's no way to differentiate a cmpDef prediction from the page
         //            requesting the cmpDef, we need to predict cmpDefs before we start watching
         //            for predictions in the page. Having this code after an
         //            await will make the predictions to be saved as predictions too.
@@ -4048,7 +4296,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.320.0-e3e5f3d984
+// version: 1.322.0-87f682c9f3
 
 const forceRecordTransactionsDisabled = getEnvironmentSetting(EnvironmentSettings.ForceRecordTransactionsDisabled);
 //TODO: Some duplication here that can be most likely moved to a util class
@@ -4552,6 +4800,11 @@ function setupPredictivePrefetcher(luvio) {
     const requestRunner = new LexRequestRunner(requestStrategyManager);
     const repository = new PrefetchRepository(storage, {
         modifyBeforeSaveHook: (requests) => requestRunner.reduceRequests(requests),
+        modifyPageBeforeSavingHook: (page) => {
+            if (RecordHomePage.handlesContext(__lexPrefetcher.context)) {
+                page.recordTypeId = __lexPrefetcher.context.recordTypeId;
+            }
+        },
     });
     const inflightRequestLimit = applyPredictionRequestLimit.isOpen({ fallback: false })
         ? getInflightRequestLimit()
@@ -4630,13 +4883,12 @@ function buildPredictorForContext(context) {
     }
     const currentContext = __lexPrefetcher.context;
     let isSameContext = false;
-    if (currentContext && currentContext.type === 'recordPage') {
-        const rhPageContext = currentContext;
+    if (RecordHomePage.handlesContext(currentContext)) {
         isSameContext =
-            rhPageContext.actionName === context.actionName &&
-                rhPageContext.objectApiName === context.objectApiName &&
-                rhPageContext.recordId === context.recordId &&
-                rhPageContext.type === context.type;
+            currentContext.actionName === context.actionName &&
+                currentContext.objectApiName === context.objectApiName &&
+                currentContext.recordId === context.recordId &&
+                currentContext.type === context.type;
     }
     // // This chunk configures which page we're going to use to try and preload.
     __lexPrefetcher.context = context;
@@ -4707,14 +4959,16 @@ function initializeOneStore() {
         instrumentationServiceDescriptor,
         buildUnauthorizedFetchServiceDescriptor(),
         buildJwtAuthorizedSfapFetchServiceDescriptor(loggerService),
+        buildCopilotFetchServiceDescriptor(loggerService),
         buildAuraNetworkService(),
         buildServiceDescriptor$4(instrumentationServiceDescriptor.service),
         buildServiceDescriptor$1(cacheServiceDescriptor.service),
-        buildServiceDescriptor$8(),
-        buildServiceDescriptor$7(),
         buildServiceDescriptor$9(),
+        buildServiceDescriptor$7(),
+        buildServiceDescriptor$a(),
         buildServiceDescriptor$6(),
         buildServiceDescriptor$5(),
+        buildServiceDescriptor$8(),
     ];
     serviceBroker.publish(services);
 }
@@ -4743,4 +4997,4 @@ function ldsEngineCreator() {
 }
 
 export { LexRequestStrategy, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.320.0-85be789480
+// version: 1.322.0-6aa042602a

package/dist/types/jwt-authorized-fetch-service.d.ts

@@ -1,6 +1,12 @@
 import { type FetchServiceDescriptor } from '@luvio/service-fetch-network/v1';
 import { type LoggerService } from '@luvio/utils';
 export declare function buildJwtAuthorizedSfapFetchServiceDescriptor(logger: LoggerService): FetchServiceDescriptor;
+/**
+ * Returns a service descriptor for a fetch service that includes one-off copilot
+ * hacks. This fetch service is not intended for use by anything other than
+ * copilot commands.
+ */
+export declare function buildCopilotFetchServiceDescriptor(logger: LoggerService): FetchServiceDescriptor;
 export declare const lightningJwtResolver: {
     getJwt(): Promise<any>;
 };

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

@@ -9,9 +9,9 @@ export type RequestEntry<Request> = {
     };
 };
 /**
- * Request and Context data to be saved.
+ * Request and context-based Key data to be saved.
  */
 export type SaveRequestData<Request, Context> = {
     request: Request;
-    context: Context;
+    key: Context;
 };

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

@@ -2,10 +2,10 @@ import type { BaseAdapterRequest } from '../request-strategy';
 import { PredictivePrefetchPage } from './predictive-prefetch-page';
 export type DefaultPageContext = Record<string, any>;
 export declare class LexDefaultPage<Request extends BaseAdapterRequest, Context extends DefaultPageContext> extends PredictivePrefetchPage<Request, Context> {
-    constructor(context: Context);
+    constructor(context: Context, similarContext?: Context);
     supportsRequest(_request: Request): boolean;
     buildSaveRequestData(request: Request): {
-        context: Context;
+        key: Context;
         request: Request;
     }[];
     resolveSimilarRequest(similarRequest: Request): Request;

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

@@ -11,11 +11,10 @@ export declare const OBJECT_HOME_SUPPORTED_ADAPTERS: Set<string>;
 export declare class ObjectHomePage extends LexDefaultPage<LexRequest, ObjectHomePageContext> {
     private requestStrategyManager;
     private options;
-    similarContext: ObjectHomePageContext;
     constructor(context: ObjectHomePageContext, requestStrategyManager: RequestStrategyManager, options: LexPrefetcherOptions);
     supportsRequest(request: LexRequest): boolean;
     buildSaveRequestData(request: LexRequest): {
-        context: ObjectHomePageContext;
+        key: ObjectHomePageContext;
         request: LexRequest<unknown>;
     }[];
     resolveSimilarRequest(similarRequest: LexRequest): LexRequest;

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

@@ -1,10 +1,12 @@
 import type { SaveRequestData } from '../common';
 export declare abstract class PredictivePrefetchPage<Request, Context> {
-    context: Context;
-    similarContext: Partial<Context> | undefined;
-    constructor(context: Context);
+    protected context: Context;
+    protected similarContext?: Context | undefined;
+    protected constructor(context: Context, similarContext?: Context | undefined);
     abstract supportsRequest(request: Request): boolean;
     abstract buildSaveRequestData(request: Request): SaveRequestData<Request, Context>[];
     abstract resolveSimilarRequest(similarRequest: Request): Request;
     abstract getAlwaysRunRequests(): Request[];
+    getExactKey(): Context;
+    getSimilarKey(): Context;
 }

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

@@ -6,17 +6,18 @@ export declare const RECORD_HOME_SUPPORTED_ADAPTERS: Set<string>;
 export type RecordHomePageContext = {
     objectApiName: string;
     recordId: string;
+    recordTypeId?: string;
     actionName: string;
     type: 'recordPage';
 };
 export declare class RecordHomePage extends LexDefaultPage<LexRequest, RecordHomePageContext> {
     private requestStrategyManager;
     private options;
-    similarContext: RecordHomePageContext;
     constructor(context: RecordHomePageContext, requestStrategyManager: RequestStrategyManager, options: LexPrefetcherOptions);
     supportsRequest(request: LexRequest): boolean;
+    getExactKey(): RecordHomePageContext;
     buildSaveRequestData(request: LexRequest): {
-        context: RecordHomePageContext;
+        key: RecordHomePageContext;
         request: LexRequest<unknown>;
     }[];
     resolveSimilarRequest(similarRequest: LexRequest): LexRequest;
@@ -35,4 +36,5 @@ export declare class RecordHomePage extends LexDefaultPage<LexRequest, RecordHom
      */
     shouldExecuteAlwaysRequestByThemself(): boolean;
     static handlesContext(context: DefaultPageContext): context is RecordHomePageContext;
+    static contextToExactKey(context: RecordHomePageContext): RecordHomePageContext;
 }

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

@@ -1,7 +1,7 @@
+import { LexDefaultPage } from '../pages';
 import { ApplicationPredictivePrefetcher } from './predictive-prefetcher';
-import { LexDefaultPage } from '../pages/lex-default-page';
 import type { RequestRunner } from '../request-runner';
-import type { PrefetchRepository } from '../repository/prefetch-repository';
+import type { PrefetchRepository } from '../repository';
 import type { RequestEntry } from '../common';
 import type { LexContext, LexPrefetcherOptions, LexRequest } from '../lex';
 import type { RequestStrategyManager } from '../request-strategy-manager/request-strategy-manager';
@@ -9,7 +9,7 @@ export declare class LexPredictivePrefetcher extends ApplicationPredictivePrefet
     protected options: LexPrefetcherOptions;
     page: LexDefaultPage<LexRequest, LexContext>;
     private requestStrategyManager;
-    constructor(context: LexContext, repository: PrefetchRepository, requestRunner: RequestRunner<LexRequest>, requestStrategyManager: RequestStrategyManager, options: LexPrefetcherOptions);
+    constructor(context: LexContext, repository: PrefetchRepository<LexRequest>, requestRunner: RequestRunner<LexRequest>, requestStrategyManager: RequestStrategyManager, options: LexPrefetcherOptions);
     getPage(): LexDefaultPage<LexRequest, LexContext>;
     getAllPageRequests(): RequestEntry<LexRequest>[];
     predict(): Promise<void>;

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

@@ -1,16 +1,16 @@
 import type { PrefetchRepository } from '../repository';
 import type { PredictivePrefetchPage } from '../pages';
 import type { RequestRunner } from '../request-runner';
-import type { RequestEntry } from '../common';
-export declare abstract class ApplicationPredictivePrefetcher<Request, Context extends Record<string, any>> {
-    protected repository: PrefetchRepository;
+import type { BaseAdapterRequest } from '../request-strategy';
+export declare abstract class ApplicationPredictivePrefetcher<Request extends BaseAdapterRequest, Context extends Record<string, any>> {
+    protected repository: PrefetchRepository<Request>;
     protected requestRunner: RequestRunner<Request>;
     private _context;
     isRecording: boolean;
     totalRequestCount: Number;
     page: PredictivePrefetchPage<Request, Context>;
     queuedPredictionRequests: Request[];
-    constructor(context: Context, repository: PrefetchRepository, requestRunner: RequestRunner<Request>);
+    protected constructor(context: Context, repository: PrefetchRepository<Request>, requestRunner: RequestRunner<Request>);
     abstract getPage(): PredictivePrefetchPage<Request, Context>;
     set context(value: Context);
     get context(): Context;
@@ -24,6 +24,11 @@ export declare abstract class ApplicationPredictivePrefetcher<Request, Context e
         totalRequestCount: Number;
     };
     hasPredictions(): boolean;
-    getSimilarPageRequests(): RequestEntry<Request>[];
-    getExactPageRequest(): RequestEntry<Request>[];
+    getSimilarPageRequests(): {
+        request: Request;
+        requestMetadata: {
+            requestTime: number;
+        };
+    }[];
+    getExactPageRequests(): import("../common").RequestEntry<Request>[];
 }

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

@@ -7,23 +7,25 @@ export type History = {
 };
 export type PageEntry<Request> = {
     id: string;
+    recordTypeId?: string;
     requests: RequestEntry<Request>[];
 };
-export type PrefetchRepositoryOptions = {
-    modifyBeforeSaveHook?: (requests: RequestEntry<any>[]) => RequestEntry<any>[];
+export type PrefetchRepositoryOptions<Request> = {
+    modifyBeforeSaveHook?: (requests: RequestEntry<Request>[]) => RequestEntry<Request>[];
+    modifyPageBeforeSavingHook?: (page: PageEntry<Request>) => void;
 };
-export declare class PrefetchRepository {
+export declare class PrefetchRepository<Request> {
     private storage;
     private options;
     private requestBuffer;
-    constructor(storage: PrefetchStorage, options?: PrefetchRepositoryOptions);
+    constructor(storage: PrefetchStorage, options?: PrefetchRepositoryOptions<Request>);
     clearRequestBuffer(): void;
     pageStartTime: number;
     markPageStart(): void;
     flushRequestsToStorage(): Promise<void>;
     getKeyId(key: Key): string;
     saveRequest<Request>(key: Key, request: Request): void;
-    getPage<Request>(key: Key): PageEntry<Request> | undefined;
-    getPageRequests<Request>(key: Key): RequestEntry<Request>[];
+    getPage(key: Key): PageEntry<Request> | undefined;
+    getPageRequests(key: Key): RequestEntry<Request>[];
 }
 export {};

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

@@ -6,6 +6,7 @@ export type GetRelatedListInfoBatchRequest = {
 };
 type GetRelatedListInfoBatchContext = {
     objectApiName: string;
+    recordTypeId: string;
 };
 export declare const GET_RELATED_LIST_INFO_BATCH_ADAPTER_NAME = "getRelatedListInfoBatch";
 export declare class GetRelatedListInfoBatchRequestStrategy extends LuvioAdapterRequestStrategy<GetRelatedListInfoBatchConfig, GetRelatedListInfoBatchRequest, GetRelatedListInfoBatchContext> {
@@ -16,6 +17,7 @@ export declare class GetRelatedListInfoBatchRequestStrategy extends LuvioAdapter
      * @override
      */
     transformForSave(request: GetRelatedListInfoBatchRequest): GetRelatedListInfoBatchRequest;
+    isContextDependent(context: GetRelatedListInfoBatchContext, request: GetRelatedListInfoBatchRequest): boolean;
     canCombine(reqA: GetRelatedListInfoBatchConfig, reqB: GetRelatedListInfoBatchConfig): boolean;
     combineRequests(reqA: GetRelatedListInfoBatchConfig, reqB: GetRelatedListInfoBatchConfig): GetRelatedListInfoBatchConfig;
 }

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

@@ -8,6 +8,7 @@ export type GetRelatedListInfoRequest = {
 };
 type GetRelatedListInfoContext = {
     objectApiName: string;
+    recordTypeId: string;
 };
 export declare const GET_RELATED_LIST_INFO_ADAPTER_NAME = "getRelatedListInfo";
 export declare class GetRelatedListInfoRequestStrategy extends LuvioAdapterRequestStrategy<GetRelatedListInfoConfig, GetRelatedListInfoRequest, GetRelatedListInfoContext> {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.320.0",
+    "version": "1.322.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -34,33 +34,34 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-aura"
     },
     "devDependencies": {
-        "@luvio/service-broker": "5.11.0",
-        "@salesforce/lds-adapters-apex": "^1.320.0",
-        "@salesforce/lds-adapters-uiapi": "^1.320.0",
+        "@luvio/service-broker": "5.13.0",
+        "@salesforce/lds-adapters-apex": "^1.322.0",
+        "@salesforce/lds-adapters-uiapi": "^1.322.0",
         "@salesforce/lds-adapters-uiapi-lex": "^1.302.0",
-        "@salesforce/lds-ads-bridge": "^1.320.0",
-        "@salesforce/lds-aura-storage": "^1.320.0",
-        "@salesforce/lds-bindings": "^1.320.0",
-        "@salesforce/lds-instrumentation": "^1.320.0",
-        "@salesforce/lds-network-aura": "^1.320.0",
-        "@salesforce/lds-network-fetch-with-jwt": "^1.320.0"
+        "@salesforce/lds-ads-bridge": "^1.322.0",
+        "@salesforce/lds-aura-storage": "^1.322.0",
+        "@salesforce/lds-bindings": "^1.322.0",
+        "@salesforce/lds-instrumentation": "^1.322.0",
+        "@salesforce/lds-network-aura": "^1.322.0",
+        "@salesforce/lds-network-fetch-with-jwt": "^1.322.0"
     },
     "dependencies": {
-        "@luvio/command-aura-network": "5.11.0",
-        "@luvio/command-fetch-network": "5.11.0",
-        "@luvio/command-network": "5.11.0",
-        "@luvio/command-sse": "5.11.0",
-        "@luvio/command-streaming": "5.11.0",
-        "@luvio/network-adapter-composable": "0.156.4",
-        "@luvio/network-adapter-fetch": "0.156.4",
-        "@luvio/service-aura-network": "5.11.0",
-        "@luvio/service-cache": "5.11.0",
-        "@luvio/service-cache-control": "5.11.0",
-        "@luvio/service-fetch-network": "5.11.0",
-        "@luvio/service-instrument-command": "5.11.0",
-        "@luvio/service-store": "5.11.0",
-        "@luvio/utils": "5.11.0",
-        "@salesforce/lds-adapters-uiapi-lex": "^1.320.0"
+        "@luvio/command-aura-network": "5.13.0",
+        "@luvio/command-aura-resource-cache-control": "5.13.0",
+        "@luvio/command-fetch-network": "5.13.0",
+        "@luvio/command-network": "5.13.0",
+        "@luvio/command-sse": "5.13.0",
+        "@luvio/command-streaming": "5.13.0",
+        "@luvio/network-adapter-composable": "0.156.5",
+        "@luvio/network-adapter-fetch": "0.156.5",
+        "@luvio/service-aura-network": "5.13.0",
+        "@luvio/service-cache": "5.13.0",
+        "@luvio/service-cache-control": "5.13.0",
+        "@luvio/service-fetch-network": "5.13.0",
+        "@luvio/service-instrument-command": "5.13.0",
+        "@luvio/service-store": "5.13.0",
+        "@luvio/utils": "5.13.0",
+        "@salesforce/lds-adapters-uiapi-lex": "^1.322.0"
     },
     "luvioBundlesize": [
         {