@salesforce/lds-runtime-aura 1.321.0 → 1.323.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,12 +1209,41 @@ class CacheController {
 
 function buildServiceDescriptor$1(cache) {
     return {
-        type: 'cacheControl',
+        type: 'cacheController',
         version: '1.0',
         service: new CacheController({ cache }),
     };
 }
 
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/**
+ * Most-recently set of published services.
+ */
+let servicesAvailable;
+new Promise((resolve) => (servicesAvailable = resolve));
+/**
+ * Sets the services that will be used to satisfy calls to getServices().
+ * Any previously registered services are replaced with the services provided.
+ * Note overwriting services should be done with great care as previous callers
+ * of getServices() will not be aware of the new services.
+ *
+ * The default implementation provided by this module only supports a single
+ * set of active services. Runtime environments that require multiple sets of
+ * active services will need to override this module with their own
+ * implementation.
+ 
+ * @param services services to be used to satisfy future getServices() requests
+ */
+function setServices(services) {
+    resolvedPromiseLike(services);
+    servicesAvailable(services);
+}
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -1550,9 +1748,79 @@ 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 jwtAuthorizedFetchService = buildServiceDescriptor({
+        request: [buildJwtRequestInterceptor(logger)],
+    });
+    return {
+        ...jwtAuthorizedFetchService,
+        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 || !token.decodedInfo || !token.decodedInfo.iss) {
+                            logger.warn('skipping injection of endpoint into start session request');
+                        }
+                        else {
+                            if (!body.instanceConfig) {
+                                body.instanceConfig = {};
+                            }
+                            body.instanceConfig.endpoint = token.decodedInfo.iss;
+                        }
+                        return [
+                            args[0],
+                            {
+                                ...args[1],
+                                body: JSON.stringify(body),
+                            },
+                        ];
+                    });
+                },
+                buildJwtRequestInterceptor(logger),
+            ],
+        }),
+        tags: { specialHacksFor: 'copilot' },
+    };
+}
+function buildUnauthorizedFetchServiceDescriptor() {
+    const fetchService = buildServiceDescriptor();
+    return {
+        ...fetchService,
+        tags: { authenticationScopes: '' },
+    };
+}
+function buildJwtRequestInterceptor(logger) {
     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,21 +1839,8 @@ function buildJwtAuthorizedSfapFetchServiceDescriptor(logger) {
         url.protocol = overrideUrl.protocol;
         return [url, request];
     };
-    const jwtRequestHeaderInterceptor = buildJwtRequestHeaderInterceptor(jwtManager, jwtRequestModifier);
-    const jwtAuthorizedFetchService = buildServiceDescriptor({
-        request: [jwtRequestHeaderInterceptor],
-    });
-    return {
-        ...jwtAuthorizedFetchService,
-        tags: { authenticationScopes: 'sfap_api' },
-    };
-}
-function buildUnauthorizedFetchServiceDescriptor() {
-    const fetchService = buildServiceDescriptor();
-    return {
-        ...fetchService,
-        tags: { authenticationScopes: '' },
-    };
+    const jwtRequestHeaderInterceptor = buildJwtRequestHeaderInterceptor(sfapJwtManager, jwtRequestModifier);
+    return jwtRequestHeaderInterceptor;
 }
 
 const PDL_EXECUTE_ASYNC_OPTIONS = {
@@ -1634,7 +1889,17 @@ const { create, keys, hasOwnProperty, entries } = Object;
 const { isArray, from } = Array;
 const { stringify } = JSON;
 
+// Note: exported enum for core usage.
+var PdlRequestPriority;
+(function (PdlRequestPriority) {
+    PdlRequestPriority[PdlRequestPriority["LOW"] = 0] = "LOW";
+    PdlRequestPriority[PdlRequestPriority["NORMAL"] = 1] = "NORMAL";
+    PdlRequestPriority[PdlRequestPriority["HIGH"] = 2] = "HIGH";
+})(PdlRequestPriority || (PdlRequestPriority = {}));
 class RequestStrategy {
+    getRequestPriority(_request, _context) {
+        return 1 /* RequestPriority.NORMAL */;
+    }
     /**
      * Perform any transformations required to prepare the request for saving.
      *
@@ -2943,6 +3208,7 @@ 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) {
@@ -3845,6 +4111,39 @@ async function runRequestsWithLimit(requests, runner, concurrentRequestsLimit, p
     // Wait for all initial requests to complete
     await Promise.all(promises);
 }
+/**
+ * Compares two request entries based on their priority and, if the priorities are the same, their request times.
+ * This function is typically used for sorting requests where priority takes precedence, and timing is used
+ * as a secondary criterion. The function assumes that any necessary filtering of requests has already been done.
+ *
+ * @template Context - Extends `DefaultPageContext`, provides additional context for the request priority determination.
+ *
+ * @param {RequestEntry<LexRequest>} requestA - The first request entry containing the request and its metadata.
+ * @param {RequestEntry<LexRequest>} requestB - The second request entry containing the request and its metadata.
+ * @param {RequestStrategyManager} requestStrategyManager - Manager that provides access to request strategies based on adapter names.
+ * @param {Context} context - The context in which the requests are being compared, used to determine request priority.
+ *
+ * @returns {number} A negative number if the first request should come before the second, a positive number if the
+ *                   second should come before the first, or zero if they are considered equal for sorting purposes.
+ *                   This is determined first by the priority (higher priority comes first) and then by the request
+ *                   time (earlier request comes first) if priorities are the same. The priorities are fetched from
+ *                   the `requestStrategyManager` for each request's `adapterName`. If a strategy is not found,
+ *                   the priority defaults to `RequestPriority.LOW`.
+ */
+function compareByPriorityThenTime({ request: requestA, requestMetadata: requestMetadataA }, { request: requestB, requestMetadata: requestMetadataB }, requestStrategyManager, context) {
+    const aPriority = requestStrategyManager.get(requestA.adapterName)?.getRequestPriority(requestA, context) ||
+        0 /* RequestPriority.LOW */;
+    const bPriority = requestStrategyManager.get(requestB.adapterName)?.getRequestPriority(requestB, context) ||
+        0 /* RequestPriority.LOW */;
+    if (aPriority === bPriority) {
+        // when both requests have the same priority, use the request time in waterfall.
+        return requestMetadataA.requestTime - requestMetadataB.requestTime;
+    }
+    else {
+        // sort by priority, descending
+        return bPriority - aPriority;
+    }
+}
 
 function isBoxcarableRequest({ request: { adapterName } }, requestStrategyManager) {
     const strategy = requestStrategyManager.get(adapterName);
@@ -3897,20 +4196,22 @@ class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
         return [...exactPageRequests, ...similarPageRequests];
     }
     async predict() {
+        // perf: caching access, to avoid this.prop in loops.
+        const { requestStrategyManager, context } = this;
         const alwaysRequests = this.page.getAlwaysRunRequests();
         const pageRequests = this.getAllPageRequests();
         // 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.
-        predictNonBoxcarableRequest(pageRequests.filter((r) => !isBoxcarableRequest(r, this.requestStrategyManager)), this.requestRunner);
+        predictNonBoxcarableRequest(pageRequests.filter((r) => !isBoxcarableRequest(r, requestStrategyManager)), this.requestRunner);
         const alwaysRequestEntries = alwaysRequests.map((request) => {
             return {
                 request,
                 requestMetadata: { requestTime: 0 }, // ensures always requests are executed, and executed first.
             };
         });
-        const boxcarablePredictions = pageRequests.filter((r) => isBoxcarableRequest(r, this.requestStrategyManager));
+        const boxcarablePredictions = pageRequests.filter((r) => isBoxcarableRequest(r, requestStrategyManager));
         const reducedPredictions = this.page.shouldReduceAlwaysRequestsWithPredictions()
             ? this.requestRunner.reduceRequests([...boxcarablePredictions, ...alwaysRequestEntries])
             : this.requestRunner.reduceRequests(boxcarablePredictions);
@@ -3918,7 +4219,7 @@ class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
             ? [...alwaysRequestEntries, ...reducedPredictions]
             : reducedPredictions)
             // Sorting in order requested
-            .sort((a, b) => a.requestMetadata.requestTime - b.requestMetadata.requestTime);
+            .sort((a, b) => compareByPriorityThenTime(a, b, requestStrategyManager, context));
         this.totalRequestCount = predictedRequestsWithLimit.length;
         await runRequestsWithLimit(predictedRequestsWithLimit, this.requestRunner, this.options.inflightRequestLimit, 
         // `this.repository.pageStartTime` would be the correct here,
@@ -4076,7 +4377,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.321.0-40847d67a8
+// version: 1.323.0-34d96539ec
 
 const forceRecordTransactionsDisabled = getEnvironmentSetting(EnvironmentSettings.ForceRecordTransactionsDisabled);
 //TODO: Some duplication here that can be most likely moved to a util class
@@ -4739,16 +5040,19 @@ 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);
+    setServices(services);
 }
 function initializeOnestoreUiApiAdapters() {
     configuration.setGetObjectInfoAdapter(getObjectInfo);
@@ -4774,5 +5078,5 @@ function ldsEngineCreator() {
     return { name: 'ldsEngineCreator' };
 }
 
-export { LexRequestStrategy, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.321.0-1fd3fba1c4
+export { LexRequestStrategy, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
+// version: 1.323.0-ddaba12fc0

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/main.d.ts

@@ -1,6 +1,7 @@
 import { type RecordHomePageContext } from './predictive-loading';
 import type { LexRequestStrategy } from './predictive-loading/request-strategy/lex-request-strategy';
 import { type LexRequest } from './predictive-loading/lex';
+export { PdlRequestPriority } from './predictive-loading';
 export { LexRequestStrategy } from './predictive-loading/request-strategy/lex-request-strategy';
 /**
  * Registers a request strategy to be utilized by PDL.

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

@@ -1,5 +1,8 @@
 import type { RequestRunner } from '../request-runner';
 import type { RequestEntry } from '../common';
+import type { LexRequest } from '../lex';
+import type { RequestStrategyManager } from '../request-strategy-manager/request-strategy-manager';
+import type { DefaultPageContext } from '../pages';
 /**
  * Runs a list of requests with a specified concurrency limit.
  *
@@ -14,3 +17,23 @@ import type { RequestEntry } from '../common';
  * 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>;
+/**
+ * Compares two request entries based on their priority and, if the priorities are the same, their request times.
+ * This function is typically used for sorting requests where priority takes precedence, and timing is used
+ * as a secondary criterion. The function assumes that any necessary filtering of requests has already been done.
+ *
+ * @template Context - Extends `DefaultPageContext`, provides additional context for the request priority determination.
+ *
+ * @param {RequestEntry<LexRequest>} requestA - The first request entry containing the request and its metadata.
+ * @param {RequestEntry<LexRequest>} requestB - The second request entry containing the request and its metadata.
+ * @param {RequestStrategyManager} requestStrategyManager - Manager that provides access to request strategies based on adapter names.
+ * @param {Context} context - The context in which the requests are being compared, used to determine request priority.
+ *
+ * @returns {number} A negative number if the first request should come before the second, a positive number if the
+ *                   second should come before the first, or zero if they are considered equal for sorting purposes.
+ *                   This is determined first by the priority (higher priority comes first) and then by the request
+ *                   time (earlier request comes first) if priorities are the same. The priorities are fetched from
+ *                   the `requestStrategyManager` for each request's `adapterName`. If a strategy is not found,
+ *                   the priority defaults to `RequestPriority.LOW`.
+ */
+export declare function compareByPriorityThenTime<Context extends DefaultPageContext = DefaultPageContext>({ request: requestA, requestMetadata: requestMetadataA }: RequestEntry<LexRequest>, { request: requestB, requestMetadata: requestMetadataB }: RequestEntry<LexRequest>, requestStrategyManager: RequestStrategyManager, context: Context): number;

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

@@ -3,6 +3,16 @@ export type BaseAdapterRequest<Config = unknown> = {
     adapterName: string;
     config: Config;
 };
+export declare const enum RequestPriority {
+    LOW = 0,
+    NORMAL = 1,
+    HIGH = 2
+}
+export declare enum PdlRequestPriority {
+    LOW = 0,
+    NORMAL = 1,
+    HIGH = 2
+}
 export declare abstract class RequestStrategy<Config, Request extends BaseAdapterRequest<Config>, Context> {
     /**
      * Name of the adapter used in this strategy.
@@ -10,6 +20,7 @@ export declare abstract class RequestStrategy<Config, Request extends BaseAdapte
     abstract adapterName: string;
     abstract execute(config: Config): any;
     abstract buildConcreteRequest(similarRequest: Request, context: Context): Request;
+    getRequestPriority(_request: Request, _context: Context): RequestPriority;
     /**
      * Perform any transformations required to prepare the request for saving.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.321.0",
+    "version": "1.323.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -34,33 +34,36 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-aura"
     },
     "devDependencies": {
-        "@luvio/service-broker": "5.12.0",
-        "@salesforce/lds-adapters-apex": "^1.321.0",
-        "@salesforce/lds-adapters-uiapi": "^1.321.0",
+        "@luvio/service-broker": "5.13.0",
+        "@luvio/service-provisioner": "5.13.0",
+        "@salesforce/lds-adapters-apex": "^1.323.0",
+        "@salesforce/lds-adapters-uiapi": "^1.323.0",
         "@salesforce/lds-adapters-uiapi-lex": "^1.302.0",
-        "@salesforce/lds-ads-bridge": "^1.321.0",
-        "@salesforce/lds-aura-storage": "^1.321.0",
-        "@salesforce/lds-bindings": "^1.321.0",
-        "@salesforce/lds-instrumentation": "^1.321.0",
-        "@salesforce/lds-network-aura": "^1.321.0",
-        "@salesforce/lds-network-fetch-with-jwt": "^1.321.0"
+        "@salesforce/lds-ads-bridge": "^1.323.0",
+        "@salesforce/lds-aura-storage": "^1.323.0",
+        "@salesforce/lds-bindings": "^1.323.0",
+        "@salesforce/lds-instrumentation": "^1.323.0",
+        "@salesforce/lds-network-aura": "^1.323.0",
+        "@salesforce/lds-network-fetch-with-jwt": "^1.323.0",
+        "jwt-encode": "1.0.1"
     },
     "dependencies": {
-        "@luvio/command-aura-network": "5.12.0",
-        "@luvio/command-fetch-network": "5.12.0",
-        "@luvio/command-network": "5.12.0",
-        "@luvio/command-sse": "5.12.0",
-        "@luvio/command-streaming": "5.12.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.12.0",
-        "@luvio/service-cache": "5.12.0",
-        "@luvio/service-cache-control": "5.12.0",
-        "@luvio/service-fetch-network": "5.12.0",
-        "@luvio/service-instrument-command": "5.12.0",
-        "@luvio/service-store": "5.12.0",
-        "@luvio/utils": "5.12.0",
-        "@salesforce/lds-adapters-uiapi-lex": "^1.321.0"
+        "@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.323.0"
     },
     "luvioBundlesize": [
         {