@salesforce/lds-runtime-aura 1.303.0 → 1.305.0

package/dist/ldsEngineCreator.js

@@ -27,14 +27,16 @@ import { serviceBroker } from 'force/luvioServiceBroker5';
 import oneStoreEnabled from '@salesforce/gate/lds.oneStoreEnabled.ltng';
 import oneStoreUiapiEnabled from '@salesforce/gate/lds.oneStoreUiapiEnabled.ltng';
 import { getDefinition, executeGlobalControllerRawResponse } from 'aura';
-import { buildJwtNetworkAdapter } from 'force/ldsNetworkFetchWithJwt';
-import auraNetworkAdapter, { dispatchAuraAction, defaultActionConfig, instrument as instrument$1, forceRecordTransactionsDisabled, ldsNetworkAdapterInstrument } from 'force/ldsNetwork';
-import { LRUCache, instrumentAdapter, instrumentLuvio, setupInstrumentation as setupInstrumentation$1, logObjectInfoChanged as logObjectInfoChanged$1, updatePercentileHistogramMetric, incrementCounterMetric, incrementGetRecordNotifyChangeAllowCount, incrementGetRecordNotifyChangeDropCount, incrementNotifyRecordUpdateAvailableAllowCount, incrementNotifyRecordUpdateAvailableDropCount, setLdsAdaptersUiapiInstrumentation, setLdsNetworkAdapterInstrumentation, executeAsyncActivity, METRIC_KEYS, onIdleDetected } from 'force/ldsInstrumentation';
-import { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR, instrument as instrument$2 } from 'force/ldsBindings';
+import { buildJwtNetworkAdapter, instrument as instrument$2, setupLexJwtNetworkAdapter } from 'force/ldsNetworkFetchWithJwt';
+import auraNetworkAdapter, { dispatchAuraAction, defaultActionConfig, instrument as instrument$1, forceRecordTransactionsDisabled as forceRecordTransactionsDisabled$1, ldsNetworkAdapterInstrument, CrudEventState, CrudEventType, UIAPI_RECORDS_PATH, UIAPI_RELATED_LIST_RECORDS_BATCH_PATH, UIAPI_RELATED_LIST_RECORDS_PATH } from 'force/ldsNetwork';
+import { LRUCache, instrumentAdapter, instrumentLuvio, setupInstrumentation as setupInstrumentation$1, logObjectInfoChanged as logObjectInfoChanged$1, updatePercentileHistogramMetric, incrementCounterMetric, incrementGetRecordNotifyChangeAllowCount, incrementGetRecordNotifyChangeDropCount, incrementNotifyRecordUpdateAvailableAllowCount, incrementNotifyRecordUpdateAvailableDropCount, setLdsAdaptersUiapiInstrumentation, logError, setLdsNetworkAdapterInstrumentation, executeAsyncActivity, METRIC_KEYS, onIdleDetected } from 'force/ldsInstrumentation';
+import { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR, instrument as instrument$3 } from 'force/ldsBindings';
 import { counter, registerCacheStats, perfStart, perfEnd, registerPeriodicLogger, interaction, timer } from 'instrumentation/service';
-import { instrument as instrument$3 } from 'force/adsBridge';
+import { instrument as instrument$4 } from 'force/adsBridge';
 import { withRegistration, register, setDefaultLuvio } from 'force/ldsEngine';
 import { createStorage, clearStorages } from 'force/ldsStorage';
+import useHttpInsteadAuraTransport from '@salesforce/gate/lds.useHttpInsteadAuraTransport';
+import { ThirdPartyTracker } from 'instrumentation:beaconLib';
 import { getObjectInfo, getObjectInfos } from 'force/ldsAdaptersUiapiLex';
 
 /**
@@ -1696,9 +1698,15 @@ class LexDefaultPage extends PredictivePrefetchPage {
     getAlwaysRunRequests() {
         return [];
     }
+    shouldReduceAlwaysRequestsWithPredictions() {
+        return true;
+    }
+    shouldExecuteAlwaysRequestByThemself() {
+        return false;
+    }
 }
 
-class RecordHomePage extends PredictivePrefetchPage {
+class RecordHomePage extends LexDefaultPage {
     constructor(context, requestStrategies, options) {
         super(context);
         this.requestStrategies = requestStrategies;
@@ -1753,6 +1761,23 @@ class RecordHomePage extends PredictivePrefetchPage {
             },
         ];
     }
+    /**
+     * In RH, we know that there will be predictions, and we want to reduce the always requests (getRecord(id, type))
+     * with one of the predictions in case some request containing the fields was missed in the predictions.
+     *
+     * @returns true
+     */
+    shouldReduceAlwaysRequestsWithPredictions() {
+        return true;
+    }
+    /**
+     * In RH, we should execute the getRecord(id, type) by itself as we want the result asap, so
+     * it does not stop rendering.
+     * @returns true
+     */
+    shouldExecuteAlwaysRequestByThemself() {
+        return true;
+    }
     static handlesContext(context) {
         const maybeRecordHomePageContext = context;
         return (maybeRecordHomePageContext !== undefined &&
@@ -1763,7 +1788,7 @@ class RecordHomePage extends PredictivePrefetchPage {
     }
 }
 
-class ObjectHomePage extends PredictivePrefetchPage {
+class ObjectHomePage extends LexDefaultPage {
     constructor(context, requestStrategies, options) {
         super(context);
         this.requestStrategies = requestStrategies;
@@ -1832,6 +1857,24 @@ class ObjectHomePage extends PredictivePrefetchPage {
             },
         ];
     }
+    /**
+     * AlwaysRequests must be reduced with predictions.
+     *
+     * @returns true
+     */
+    shouldReduceAlwaysRequestsWithPredictions() {
+        return true;
+    }
+    /**
+     * In OH, the always requests are reduced with predictions, and because they
+     * can't be merged with other predictions, they will always run by themself.
+     * This value must be `false`, otherwise we may see repeated requests.
+     *
+     * @returns false
+     */
+    shouldExecuteAlwaysRequestByThemself() {
+        return false;
+    }
     // Identifies a valid ObjectHomeContext
     static handlesContext(context) {
         const maybeObjectHomePageContext = context;
@@ -1888,8 +1931,8 @@ const TOTAL_ADAPTER_REQUEST_SUCCESS_COUNT = {
     },
 };
 
-const { create, keys } = Object;
-const { isArray } = Array;
+const { create, keys, hasOwnProperty } = Object;
+const { isArray, from } = Array;
 const { stringify } = JSON;
 
 /**
@@ -2365,16 +2408,19 @@ function setAuraInstrumentationHooks() {
         networkResponse: incrementRequestResponseCount,
     });
     instrument$2({
+        error: logError,
+    });
+    instrument$3({
         refreshCalled: instrumentation.handleRefreshApiCall.bind(instrumentation),
         instrumentAdapter: instrumentation.instrumentAdapter.bind(instrumentation),
     });
-    instrument$3({
+    instrument$4({
         timerMetricAddDuration: updateTimerMetric,
     });
     // Our getRecord through aggregate-ui CRUD logging has moved
     // to lds-network-adapter. We still need to respect the
     // orgs environment setting
-    if (forceRecordTransactionsDisabled === false) {
+    if (forceRecordTransactionsDisabled$1 === false) {
         ldsNetworkAdapterInstrument({
             getRecordAggregateResolve: (cb) => {
                 const { recordId, apiName } = cb();
@@ -2516,10 +2562,11 @@ async function runRequestsWithLimit(requests, runner, concurrentRequestsLimit, p
     // queue for pending prediction requests
     const requestQueue = [...requests];
     // Function to process the next request in the queue
-    const processNextRequest = async () => {
-        const timeInWaterfall = Date.now() - pageStartTime - 5; /* 5ms padding */
+    const processNextRequest = async (verifyPastTime = true) => {
+        const timeInWaterfall = Date.now() - pageStartTime;
         while (requestQueue.length > 0 &&
-            requestQueue[0].requestMetadata.requestTime < timeInWaterfall) {
+            verifyPastTime &&
+            requestQueue[0].requestMetadata.requestTime <= timeInWaterfall) {
             requestQueue.shift();
         }
         if (requestQueue.length > 0) {
@@ -2538,7 +2585,13 @@ async function runRequestsWithLimit(requests, runner, concurrentRequestsLimit, p
     const initialRequests = Math.min(concurrentRequestsLimit, requestQueue.length);
     const promises = [];
     for (let i = 0; i < initialRequests; i++) {
-        promises.push(processNextRequest());
+        // Initial requests should always execute, without verifying if they are past due.
+        // Reasoning:
+        //   It may be that one of the alwaysRequest (with 0 as start time) that is reduced
+        //   with the regular requests to make these to have 0 as the initial time in the waterfall.
+        //   Because predictions are behind an await (see W-16139321), it could be that when this code is evaluated
+        //   is already past time for the request.
+        promises.push(processNextRequest(false));
     }
     // Wait for all initial requests to complete
     await Promise.all(promises);
@@ -2547,6 +2600,10 @@ async function runRequestsWithLimit(requests, runner, concurrentRequestsLimit, p
 function isCmpDefsRequest({ request: { adapterName } }) {
     return adapterName === 'getComponentsDef';
 }
+function predictComponentDefs(cmpDefPredictions, requestRunner) {
+    const reducedPredictions = requestRunner.reduceRequests(cmpDefPredictions);
+    reducedPredictions.map((request) => requestRunner.runRequest(request.request));
+}
 class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
     constructor(context, repository, requestRunner, 
     // These strategies need to be in sync with the "predictiveDataLoadCapable" list
@@ -2576,36 +2633,35 @@ class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
     }
     async predict() {
         const alwaysRequests = this.page.getAlwaysRunRequests();
-        // IMPORTANT: The `await` has no effect on this operation because `getAllPageRequests`
-        //            is sync; however if removed, it will have a negative effect when used with
-        //            Aura Network: predictions will be boxcar'd, which likely will result in a
-        //            perf regression.
-        const pageRequests = await this.getAllPageRequests();
+        const pageRequests = this.getAllPageRequests();
+        // IMPORTANT: Because there's no way to diferentiate 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.
+        predictComponentDefs(pageRequests.filter(isCmpDefsRequest), this.requestRunner);
         const alwaysRequestEntries = alwaysRequests.map((request) => {
             return {
                 request,
                 requestMetadata: { requestTime: 0 }, // ensures always requests are executed, and executed first.
             };
         });
-        const reducedPredictions = this.requestRunner.reduceRequests([
-            ...pageRequests,
-            ...alwaysRequestEntries,
-        ]); // In future - remove alwaysRequestEntries when on OneStore
-        const nonCmpDefPredictions = reducedPredictions.filter((r) => !isCmpDefsRequest(r));
-        const cmpDefPredictions = reducedPredictions.filter(isCmpDefsRequest);
-        // Non CmpDefs requests are limited by AuraActions concurent inflight limit.
-        // Always requests must go by themself - Some of them are essential to keep the page rendering at the beginning.
-        const predictedRequestsWithLimit = [...alwaysRequestEntries, ...nonCmpDefPredictions].sort((a, b) => a.requestMetadata.requestTime - b.requestMetadata.requestTime); // In future - choose sort algorithm via Gate?;
-        const inflightPredictionRequests = runRequestsWithLimit(predictedRequestsWithLimit, this.requestRunner, this.options.inflightRequestLimit, this.repository.pageStartTime);
-        const inflightCmpRequests = cmpDefPredictions.map((request) => this.requestRunner.runRequest(request.request));
-        return Promise.all([inflightPredictionRequests, ...inflightCmpRequests]).then();
+        const nonCmpDefPredictions = pageRequests.filter((r) => !isCmpDefsRequest(r));
+        const reducedPredictions = this.page.shouldReduceAlwaysRequestsWithPredictions()
+            ? this.requestRunner.reduceRequests([...nonCmpDefPredictions, ...alwaysRequestEntries])
+            : this.requestRunner.reduceRequests(nonCmpDefPredictions);
+        const predictedRequestsWithLimit = (this.page.shouldExecuteAlwaysRequestByThemself()
+            ? [...alwaysRequestEntries, ...reducedPredictions]
+            : reducedPredictions).sort((a, b) => a.requestMetadata.requestTime - b.requestMetadata.requestTime); // In future - choose sort algorithm via Gate?;
+        await runRequestsWithLimit(predictedRequestsWithLimit, this.requestRunner, this.options.inflightRequestLimit, 
+        // `this.repository.pageStartTime` would be the correct here,
+        // but when doing predict+watch, it could be (set in watch)
+        // repository.startTime is not set yet, Date.now() is a better alternative,
+        // that is correct, and works on both cases.
+        Date.now());
     }
 }
 
 // Copy-pasted from adapter-utils. This util should be extracted from generated code and imported in prefetch repository.
-const { keys: ObjectKeys$2 } = Object;
-const { stringify: JSONStringify } = JSON;
-const { isArray: ArrayIsArray$1 } = Array;
 /**
  * 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:
@@ -2629,11 +2685,11 @@ function stableJSONStringify(node) {
         return isFinite(node) ? '' + node : 'null';
     }
     if (typeof node !== 'object') {
-        return JSONStringify(node);
+        return stringify(node);
     }
     let i;
     let out;
-    if (ArrayIsArray$1(node)) {
+    if (isArray(node)) {
         out = '[';
         for (i = 0; i < node.length; i++) {
             if (i) {
@@ -2646,10 +2702,10 @@ function stableJSONStringify(node) {
     if (node === null) {
         return 'null';
     }
-    const keys = ObjectKeys$2(node).sort();
+    const keys$1 = keys(node).sort();
     out = '';
-    for (i = 0; i < keys.length; i++) {
-        const key = keys[i];
+    for (i = 0; i < keys$1.length; i++) {
+        const key = keys$1[i];
         const value = stableJSONStringify(node[key]);
         if (!value) {
             continue;
@@ -2657,7 +2713,7 @@ function stableJSONStringify(node) {
         if (out) {
             out += ',';
         }
-        out += JSONStringify(key) + ':' + value;
+        out += stringify(key) + ':' + value;
     }
     return '{' + out + '}';
 }
@@ -2673,8 +2729,8 @@ function deepEquals(objA, objB) {
     if (!isObject(objA) || !isObject(objB))
         return false;
     // Filter out keys set as undefined, we can compare undefined as equals.
-    const keysA = ObjectKeys$2(objA).filter((key) => objA[key] !== undefined);
-    const keysB = ObjectKeys$2(objB).filter((key) => objB[key] !== undefined);
+    const keysA = keys(objA).filter((key) => objA[key] !== undefined);
+    const keysB = keys(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;
@@ -2940,9 +2996,10 @@ function requestComponents(config) {
     try {
         for (let index = 0, n = config.length; index < n; index++) {
             const def = config[index];
-            if (!(def.includes('forceGenerated') ||
-                def.includes('one:onePreloads') ||
-                onePreloads.has(def))) {
+            if (def.startsWith('markup://') &&
+                !(def.includes('forceGenerated') ||
+                    def.includes('one:onePreloads') ||
+                    onePreloads.has(def))) {
                 getDefinition(def, noop);
             }
         }
@@ -2965,9 +3022,10 @@ class GetComponentsDefStrategy extends RequestStrategy {
         };
     }
     transformForSave(request) {
+        const normalizedConfig = (request.config || []).map((def) => def.indexOf('://') === -1 ? 'markup://' + def : def);
         return {
             ...request,
-            config: request.config || [],
+            config: normalizedConfig,
         };
     }
     canCombine() {
@@ -2985,7 +3043,14 @@ class GetComponentsDefStrategy extends RequestStrategy {
 
 const LDS_PDL_CMP_IDENTIFIER = 'lds:pdl';
 const DEFAULT_RESOURCE_CONTEXT = {
-    sourceContext: { tagName: LDS_PDL_CMP_IDENTIFIER },
+    sourceContext: {
+        tagName: LDS_PDL_CMP_IDENTIFIER,
+        actionConfig: {
+            background: false,
+            hotspot: true,
+            longRunning: false,
+        },
+    },
 };
 class LuvioAdapterRequestStrategy extends RequestStrategy {
     constructor(luvio) {
@@ -3155,7 +3220,7 @@ class GetRecordsRequestStrategy extends LuvioAdapterRequestStrategy {
 }
 
 function normalizeRecordIds(recordIds) {
-    if (!ArrayIsArray$1(recordIds)) {
+    if (!isArray(recordIds)) {
         return [recordIds];
     }
     return recordIds;
@@ -3164,7 +3229,7 @@ function normalizeApiNames(apiNames) {
     if (apiNames === undefined || apiNames === null) {
         return [];
     }
-    return ArrayIsArray$1(apiNames) ? apiNames : [apiNames];
+    return isArray(apiNames) ? apiNames : [apiNames];
 }
 class GetRecordActionsRequestStrategy extends LuvioAdapterRequestStrategy {
     constructor() {
@@ -3331,11 +3396,9 @@ class GetObjectInfoRequestStrategy extends LuvioAdapterRequestStrategy {
     }
 }
 
-const { keys: ObjectKeys$1 } = Object;
-const { isArray: ArrayIsArray, from: ArrayFrom } = Array;
 function isReduceAbleRelatedListConfig(config) {
     return config.relatedListsActionParameters.every((rlReq) => {
-        return rlReq.relatedListId !== undefined && ObjectKeys$1(rlReq).length === 1;
+        return rlReq.relatedListId !== undefined && keys(rlReq).length === 1;
     });
 }
 class GetRelatedListsActionsRequestStrategy extends LuvioAdapterRequestStrategy {
@@ -3379,7 +3442,7 @@ class GetRelatedListsActionsRequestStrategy extends LuvioAdapterRequestStrategy
      */
     canCombine(reqA, reqB) {
         const [recordIdA, recordIdB] = [reqA.recordIds, reqB.recordIds].map((recordIds) => {
-            return ArrayIsArray(recordIds)
+            return isArray(recordIds)
                 ? recordIds.length === 1
                     ? recordIds[0]
                     : null
@@ -3397,7 +3460,7 @@ class GetRelatedListsActionsRequestStrategy extends LuvioAdapterRequestStrategy
         });
         return {
             recordIds: reqA.recordIds,
-            relatedListsActionParameters: ArrayFrom(relatedListsIncluded).map((relatedListId) => ({
+            relatedListsActionParameters: from(relatedListsIncluded).map((relatedListId) => ({
                 relatedListId,
             })),
         };
@@ -3539,9 +3602,18 @@ class GetRelatedListRecordsRequestStrategy extends LuvioAdapterRequestStrategy {
     }
 }
 
+const APEX_RESOURCE_CONTEXT = {
+    ...DEFAULT_RESOURCE_CONTEXT,
+    sourceContext: {
+        ...DEFAULT_RESOURCE_CONTEXT.sourceContext,
+        // We don't want to override anything for Apex, it is not part
+        // of UiApi, and it can cause undesired behavior.
+        actionConfig: undefined,
+    },
+};
 function getApexPdlFactory(luvio) {
-    return ({ invokerParams, config }) => {
-        return GetApexWireAdapterFactory(luvio, invokerParams)(config);
+    return ({ invokerParams, config }, requestContext) => {
+        return GetApexWireAdapterFactory(luvio, invokerParams)(config, requestContext);
     };
 }
 class GetApexRequestStrategy extends LuvioAdapterRequestStrategy {
@@ -3553,6 +3625,9 @@ class GetApexRequestStrategy extends LuvioAdapterRequestStrategy {
     buildConcreteRequest(similarRequest) {
         return similarRequest;
     }
+    execute(config, _requestContext) {
+        return super.execute(config, APEX_RESOURCE_CONTEXT);
+    }
 }
 
 const GET_LIST_INFO_BY_NAME_ADAPTER_NAME = 'getListInfoByName';
@@ -3717,7 +3792,6 @@ class InMemoryPrefetchStorage {
     }
 }
 
-const { keys: ObjectKeys } = Object;
 const DEFAULT_STORAGE_OPTIONS = {
     name: 'ldsPredictiveLoading',
     persistent: true,
@@ -3756,7 +3830,7 @@ class AuraPrefetchStorage {
          *    then they will (potentially incorrectly) think that we don't have any predictions.
          */
         auraStorage.getAll().then((results) => {
-            ObjectKeys(results).forEach((key) => this.inMemoryStorage.set(key, results[key]));
+            keys(results).forEach((key) => this.inMemoryStorage.set(key, results[key]));
         });
     }
     set(key, value) {
@@ -3792,9 +3866,308 @@ function buildComposableNetworkAdapter(composedAdapters) {
     };
 }
 
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/*
+ *  ATTENTION!
+ *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
+ *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
+ *  Any changes made to this file in p4 will be automatically overwritten.
+ *  *******************************************************************************************
+ */
+/* proxy-compat-disable */
+var EnvironmentSettings;
+(function (EnvironmentSettings) {
+    EnvironmentSettings["ForceRecordTransactionsDisabled"] = "forceRecordTransactionsDisabled";
+})(EnvironmentSettings || (EnvironmentSettings = {}));
+const GATE_FORCE_RECORD_TRANSACTIONS_DISABLED = '$Browser.S1Features.forceRecordTransactionsDisabled';
+const supportedEnvironmentSettings = {
+    [EnvironmentSettings.ForceRecordTransactionsDisabled]: GATE_FORCE_RECORD_TRANSACTIONS_DISABLED,
+};
+/**
+ * Returns aura configuration settings. Used to check gate/perm statuses.
+ * @param name Name of the setting to check.
+ * @returns Value of the setting, or undefined if $A is not available.
+ */
+function getEnvironmentSetting(name) {
+    if (typeof window === 'undefined') {
+        // server environment i.e. SSR in LWR
+        return undefined;
+    }
+    const environmentSetting = supportedEnvironmentSettings[name];
+    if (typeof window.$A !== 'undefined' && environmentSetting !== undefined) {
+        return window.$A.get(environmentSetting);
+    }
+    return undefined;
+}
+// version: 1.305.0-ec92f7304c
+
+const forceRecordTransactionsDisabled = getEnvironmentSetting(EnvironmentSettings.ForceRecordTransactionsDisabled);
+//TODO: Some duplication here that can be most likely moved to a util class
+const NO_RECORD_ID_204 = '204_NO_RECORD_ID';
+const NO_RECORD_TYPE_204 = '204_NO_RECORD_TYPE';
+let crudInstrumentationCallbacks = {};
+let crudRLInstrumentationCallbacks = {};
+if (forceRecordTransactionsDisabled === false) {
+    // Record callbacks
+    crudInstrumentationCallbacks = {
+        createRecordRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.CREATE, {
+                // recordId: config.params.recordInput.apiName, // seems wrong?
+                recordId: config.params.recordId || NO_RECORD_ID_204,
+                state: CrudEventState.ERROR,
+            });
+        },
+        createRecordResolveFunction: (config) => {
+            const recordId = config.body ? config.body.id : NO_RECORD_ID_204;
+            const recordType = config.body ? config.body.apiName : NO_RECORD_TYPE_204;
+            logCRUDLightningInteraction(CrudEventType.CREATE, {
+                recordId,
+                recordType,
+                state: CrudEventState.SUCCESS,
+            });
+        },
+        deleteRecordRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.DELETE, {
+                recordId: config.params.recordId,
+                state: CrudEventState.ERROR,
+            });
+        },
+        deleteRecordResolveFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.DELETE, {
+                recordId: config.params.recordId,
+                state: CrudEventState.SUCCESS,
+            });
+        },
+        // These should be handled by the network adapater?
+        // getRecordAggregateRejectFunction: (config: InstrumentationRejectConfig) => {
+        //     logCRUDLightningInteraction(CrudEventType.READ, {
+        //         recordId: config.params.recordId,
+        //         state: CrudEventState.ERROR,
+        //     });
+        // },
+        // getRecordAggregateResolveFunction: (config: InstrumentationResolveConfig) => {
+        //     logCRUDLightningInteraction(CrudEventType.READ, {
+        //         recordId: config.params.recordId,
+        //         recordType: config.body.apiName,
+        //         state: CrudEventState.SUCCESS,
+        //     });
+        // },
+        getRecordRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.READ, {
+                recordId: config.params.recordId,
+                state: CrudEventState.ERROR,
+            });
+        },
+        getRecordResolveFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.READ, {
+                recordId: config.params.recordId,
+                recordType: config.body.apiName,
+                state: CrudEventState.SUCCESS,
+            });
+        },
+        updateRecordRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.UPDATE, {
+                recordId: config.params.recordId,
+                state: CrudEventState.ERROR,
+            });
+        },
+        updateRecordResolveFunction: (config) => {
+            const recordType = config.body ? config.body.apiName : NO_RECORD_TYPE_204;
+            logCRUDLightningInteraction(CrudEventType.UPDATE, {
+                recordId: config.params.recordId,
+                recordType,
+                state: CrudEventState.SUCCESS,
+            });
+        },
+    };
+    // Related list callbacks
+    crudRLInstrumentationCallbacks = {
+        getRelatedListRecordsRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.READS, {
+                parentRecordId: config.params.parentRecordId,
+                relatedListId: config.params.relatedListId,
+                state: CrudEventState.ERROR,
+            });
+        },
+        getRelatedListRecordsResolveFunction: (config) => {
+            logGetRelatedListRecordsInteraction(config.body);
+        },
+        getRelatedListRecordsBatchRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.READS, {
+                parentRecordId: config.params.parentRecordId,
+                relatedListIds: config.params.relatedListParameters.map((entry) => entry.relatedListId),
+                state: CrudEventState.ERROR,
+            });
+        },
+        getRelatedListRecordsBatchResolveFunction: (config) => {
+            config.body.results.forEach((res) => {
+                // Log for each RL that was returned from batch endpoint
+                if (res.statusCode === 200) {
+                    logGetRelatedListRecordsInteraction(res.result);
+                }
+            });
+        },
+    };
+}
+// Helper function copied from ui-api
+function logGetRelatedListRecordsInteraction(body) {
+    const records = body.records;
+    // Don't log anything if the related list has no records.
+    if (records.length === 0) {
+        return;
+    }
+    const recordIds = records.map((record) => {
+        return record.id;
+    });
+    /**
+     *  In almost every case - the relatedList records will all be of the same apiName, but there is an edge case for
+        Activities entity that could return Events & Tasks- so handle that case by returning a joined string.
+        ADS Implementation only looks at the first record returned to determine the apiName.
+        See force/recordLibrary/recordMetricsPlugin.js _getRecordType method.
+     */
+    logCRUDLightningInteraction(CrudEventType.READS, {
+        parentRecordId: body.listReference.inContextOfRecordId,
+        relatedListId: body.listReference.relatedListId,
+        recordIds,
+        recordType: body.records[0].apiName,
+        state: CrudEventState.SUCCESS,
+    });
+}
+const crudInstrumentationConfig = {
+    records: {
+        post: {
+            rejectFn: crudInstrumentationCallbacks.createRecordRejectFunction,
+            resolveFn: crudInstrumentationCallbacks.createRecordResolveFunction,
+        },
+        get: {
+            rejectFn: crudInstrumentationCallbacks.getRecordRejectFunction,
+            resolveFn: crudInstrumentationCallbacks.getRecordResolveFunction,
+        },
+        patch: {
+            rejectFn: crudInstrumentationCallbacks.updateRecordRejectFunction,
+            resolveFn: crudInstrumentationCallbacks.updateRecordResolveFunction,
+        },
+        delete: {
+            rejectFn: crudInstrumentationCallbacks.deleteRecordRejectFunction,
+            resolveFn: crudInstrumentationCallbacks.deleteRecordResolveFunction,
+        },
+    },
+    relatedListRecords: {
+        post: {
+            rejectFn: crudRLInstrumentationCallbacks.getRelatedListRecordsRejectFunction,
+            resolveFn: crudRLInstrumentationCallbacks.getRelatedListRecordsResolveFunction,
+        },
+    },
+    relatedListRecordsBatch: {
+        post: {
+            rejectFn: crudRLInstrumentationCallbacks.getRelatedListRecordsBatchRejectFunction,
+            resolveFn: crudRLInstrumentationCallbacks.getRelatedListRecordsBatchResolveFunction,
+        },
+    },
+};
+function checkAndLogCrudInteraction(request, isResolve, error, response) {
+    let configPath;
+    const baseUrl = `${request.baseUri}${request.basePath}`;
+    if (baseUrl.startsWith(UIAPI_RECORDS_PATH)) {
+        configPath = crudInstrumentationConfig['records']; // maybe use a constant for this
+    }
+    else if (baseUrl.startsWith(UIAPI_RELATED_LIST_RECORDS_BATCH_PATH)) {
+        configPath = crudInstrumentationConfig['relatedListRecordsBatch'];
+    }
+    else if (baseUrl.startsWith(UIAPI_RELATED_LIST_RECORDS_PATH)) {
+        configPath = crudInstrumentationConfig['relatedListRecords'];
+    }
+    if (configPath) {
+        const crudCallbacks = configPath[request.method];
+        if (crudCallbacks) {
+            if (isResolve && crudCallbacks.resolveFn) {
+                crudCallbacks.resolveFn(setResolveConfig(request, response));
+            }
+            else if (crudCallbacks.rejectFn) {
+                crudCallbacks.rejectFn(setRejectConfig(request, error));
+            }
+        }
+    }
+}
+function setResolveConfig(request, response) {
+    const responseBody = response ? response.body : {};
+    const urlParams = request.urlParams || {};
+    return {
+        body: responseBody,
+        params: {
+            recordId: urlParams.recordId,
+        },
+    };
+}
+function setRejectConfig(request, error) {
+    const requestBody = request.body || {};
+    const urlParams = request.urlParams || {};
+    return {
+        err: error,
+        params: {
+            recordId: urlParams.recordId,
+            // pass these in even if they're undefined
+            parentRecordId: urlParams.parentRecordId,
+            relatedListId: urlParams.relatedListId,
+            relatedListParameters: requestBody.relatedListParameters,
+        },
+    };
+}
+
+const UIAPI_FAMILY = '/ui-api/'; // swap this to an allowlist per family (or build it off package.jsons?)
+// Denylist
+const PRIVATE_RESOURCES = ['record-avatars', 'user-state']; // These resources have Connect client filters, must be requested through UiTier :eyeroll:
+function isPrivatePath(basePath) {
+    return PRIVATE_RESOURCES.some((privateResource) => basePath.includes(privateResource));
+}
+const modifyLexResourceRequest = function (resourceRequest, jwtToken) {
+    const jwtBaseUri = jwtToken.decodedInfo.iss;
+    return {
+        ...resourceRequest,
+        baseUri: jwtBaseUri + resourceRequest.baseUri,
+    };
+};
+const requestTracker = {
+    registerHandler: (request, name, loadedCheck) => {
+        ThirdPartyTracker.registerHandler(request, name, loadedCheck);
+    },
+    markFinished: (request) => {
+        ThirdPartyTracker.markLoaded(request);
+    },
+};
+const requestLogger = {
+    resolve: (request, response = {}) => {
+        checkAndLogCrudInteraction(request, true, null, response);
+    },
+    reject: (request, error) => {
+        checkAndLogCrudInteraction(request, false, error);
+    },
+};
+const composedFetchNetworkAdapter = {
+    shouldHandleRequest(resourceRequest) {
+        return (resourceRequest.basePath.startsWith(UIAPI_FAMILY) &&
+            !isPrivatePath(resourceRequest.basePath));
+    },
+    adapter: setupLexJwtNetworkAdapter(auraNetworkAdapter, modifyLexResourceRequest, requestTracker, requestLogger),
+};
+
+function getComposedAdapters() {
+    const composedAdapters = [
+        composedNetworkAdapter$1, // SFAP adapter
+    ];
+    if (useHttpInsteadAuraTransport.isOpen({ fallback: false })) {
+        composedAdapters.push(composedFetchNetworkAdapter); // UIAPI Fetch adapter?
+    }
+    return composedAdapters;
+}
 const composedNetworkAdapter = buildComposableNetworkAdapter([
-    composedNetworkAdapter$1,
-    // The  aura network adapter must be the default.
+    ...getComposedAdapters(),
+    // The aura network adapter must be the default.
     {
         shouldHandleRequest() {
             return true;
@@ -3854,12 +4227,20 @@ function setupQueryEvaluators(luvio, store) {
 }
 let __lexPrefetcher;
 const HARDCODED_REQUEST_LIMIT = 9;
+function getInflightRequestLimit() {
+    try {
+        return window['$A'].clientService.maxAllowedParallelXHRCounts() - 3;
+    }
+    catch (e) {
+        return HARDCODED_REQUEST_LIMIT;
+    }
+}
 function setupPredictivePrefetcher(luvio) {
     const storage = buildAuraPrefetchStorage();
     const repository = new PrefetchRepository(storage);
     const requestRunner = new LexRequestRunner(luvio);
     const inflightRequestLimit = applyPredictionRequestLimit.isOpen({ fallback: false })
-        ? HARDCODED_REQUEST_LIMIT
+        ? getInflightRequestLimit()
         : 1000;
     const useExactMatchesPlus = useExactMatchesPlusGate.isOpen({ fallback: false });
     const prefetcherOptions = {
@@ -3889,30 +4270,31 @@ function setupPredictivePrefetcher(luvio) {
         registerPrefetcher$1(luvio, prefetcher);
     }
     __lexPrefetcher = prefetcher;
-    if (useCmpDefPredictions.isOpen({ fallback: false })) {
-        window['$A'].installOverride('ComponentDefLoader.loadingComplete', (...args) => {
-            /**
-             * To install an override (taken from the Aura.Utils.Override):
-             *
-             * The function supplied should have the following code in it:
-             * ------
-             *  var config = Array.prototype.shift.apply(arguments);
-             *  var ret = config["fn"].apply(config["scope"], arguments);
-             *  return ret
-             * ------
-             */
-            const config = Array.prototype.shift.apply(args);
-            const ret = config['fn'].apply(config['scope'], args);
-            const [hasErrors, descriptors] = args;
-            if (!hasErrors && Array.isArray(descriptors) && descriptors.length > 0) {
-                __lexPrefetcher.saveRequest({
-                    adapterName: 'getComponentsDef',
-                    config: descriptors,
-                });
-            }
-            return ret;
+}
+function loadComponentsDefStartedOverride(...args) {
+    /**
+     * To install an override (taken from the Aura.Utils.Override):
+     *
+     * The function supplied should have the following code in it:
+     * ------
+     *  var config = Array.prototype.shift.apply(arguments);
+     *  var ret = config["fn"].apply(config["scope"], arguments);
+     *  return ret
+     * ------
+     */
+    const config = Array.prototype.shift.apply(args);
+    const ret = config['fn'].apply(config['scope'], args);
+    try {
+        const defs = keys(args[0] || {});
+        __lexPrefetcher.saveRequest({
+            adapterName: 'getComponentsDef',
+            config: defs,
         });
     }
+    catch (e) {
+        // dismiss any error, the activity will log it.
+    }
+    return ret;
 }
 /**
  * @typedef {Object} RecordHomePageContext
@@ -3953,8 +4335,14 @@ function buildPredictorForContext(context) {
         watchPageLoadForPredictions() {
             // This chunk tells the prefetcher to receive events, send off any predictions we have from previous loads, then setup idle detection to stop predicting.
             __lexPrefetcher.startRecording();
+            if (useCmpDefPredictions.isOpen({ fallback: false })) {
+                window['$A'].installOverride('ComponentService.loadComponentDefsStarted', loadComponentsDefStartedOverride);
+            }
             onIdleDetected(() => {
                 __lexPrefetcher.stopRecording();
+                if (useCmpDefPredictions.isOpen({ fallback: false })) {
+                    window['$A'].uninstallOverride('ComponentService.loadComponentDefsStarted', loadComponentsDefStartedOverride);
+                }
             });
         },
         runPredictions() {
@@ -4067,4 +4455,4 @@ function ldsEngineCreator() {
 }
 
 export { buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore };
-// version: 1.303.0-a698c7cc67
+// version: 1.305.0-ec970f4bea

package/dist/types/__mocks__/@salesforce/lds-network-fetch-with-jwt.d.ts

@@ -1 +1,3 @@
 export declare function buildJwtNetworkAdapter(): void;
+export declare function setupLexJwtNetworkAdapter(): void;
+export declare function instrument(): void;

package/dist/types/__mocks__/instrumentation:beaconLib.d.ts

@@ -0,0 +1,7 @@
+declare function registerHandler(_cmp: any, _name: string, _loadedCheck: () => boolean): void;
+declare function markLoaded(_cmp: any): void;
+export declare const ThirdPartyTracker: {
+    registerHandler: typeof registerHandler;
+    markLoaded: typeof markLoaded;
+};
+export {};

package/dist/types/language.d.ts

@@ -0,0 +1,18 @@
+declare const create: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+}, keys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, hasOwnProperty: (v: PropertyKey) => boolean;
+declare const isArray: (arg: any) => arg is any[], from: {
+    <T>(arrayLike: ArrayLike<T>): T[];
+    <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+    <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+    <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+};
+declare const stringify: {
+    (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
+    (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
+};
+export { create as ObjectCreate, keys as ObjectKeys, hasOwnProperty as ObjectHasOwnProperty, isArray as ArrayIsArray, from as ArrayFrom, stringify as JSONStringify, };

package/dist/types/network-fetch.d.ts

@@ -0,0 +1,8 @@
+import { type ResourceRequest } from '@luvio/engine';
+import type { ModifyResourceRequestHook, RequestLogger } from '@salesforce/lds-network-fetch-with-jwt';
+export declare const modifyLexResourceRequest: ModifyResourceRequestHook<unknown, any>;
+export declare const requestLogger: RequestLogger;
+export declare const composedFetchNetworkAdapter: {
+    shouldHandleRequest(resourceRequest: ResourceRequest): boolean;
+    adapter: import("@luvio/engine").NetworkAdapter;
+};

package/dist/types/network-instrumentation.d.ts

@@ -0,0 +1,2 @@
+import type { FetchResponse, ResourceRequest } from '@luvio/engine';
+export declare function checkAndLogCrudInteraction(request: ResourceRequest, isResolve: boolean, error: any, response?: FetchResponse<any>): void;

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

@@ -1,12 +1,14 @@
 import type { LexRequest } from '../prefetcher';
 import { PredictivePrefetchPage } from './predictive-prefetch-page';
 export type DefaultPageContext = Record<string, any>;
-export declare class LexDefaultPage extends PredictivePrefetchPage<LexRequest, DefaultPageContext> {
-    constructor(context: DefaultPageContext);
-    buildSaveRequestData(request: LexRequest): {
-        context: DefaultPageContext;
-        request: LexRequest;
+export declare class LexDefaultPage<Request extends LexRequest, Context extends DefaultPageContext> extends PredictivePrefetchPage<Request, Context> {
+    constructor(context: Context);
+    buildSaveRequestData(request: Request): {
+        context: Context;
+        request: Request;
     }[];
-    resolveSimilarRequest(similarRequest: LexRequest): LexRequest;
-    getAlwaysRunRequests(): LexRequest[];
+    resolveSimilarRequest(similarRequest: Request): Request;
+    getAlwaysRunRequests(): Request[];
+    shouldReduceAlwaysRequestsWithPredictions(): boolean;
+    shouldExecuteAlwaysRequestByThemself(): boolean;
 }

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

@@ -1,13 +1,13 @@
 import type { LexContext, LexPrefetcherOptions } from '../prefetcher';
 import type { GetListInfoByNameRequestStrategy, GetListInfoByNameRequest, GetListRecordsByNameRequestStrategy, GetListRecordsByNameRequest, GetListInfosByObjectNameRequestStrategy, GetListInfosByObjectNameRequest, GetObjectInfosRequest, GetObjectInfosRequestStrategy, GetListObjectInfoRequest, GetListObjectInfoRequestStrategy } from '../request-strategy';
-import { PredictivePrefetchPage } from './predictive-prefetch-page';
+import { LexDefaultPage } from './lex-default-page';
 export type ObjectHomePageContext = {
     objectApiName: string;
     listViewApiName: string;
     type: 'objectHomePage';
 };
 export type ObjectHomePageRequest = GetListInfoByNameRequest | GetListObjectInfoRequest | GetListRecordsByNameRequest | GetListInfosByObjectNameRequest | GetObjectInfosRequest;
-export declare class ObjectHomePage extends PredictivePrefetchPage<ObjectHomePageRequest, ObjectHomePageContext> {
+export declare class ObjectHomePage extends LexDefaultPage<ObjectHomePageRequest, ObjectHomePageContext> {
     private requestStrategies;
     private options;
     similarContext: ObjectHomePageContext;
@@ -24,5 +24,19 @@ export declare class ObjectHomePage extends PredictivePrefetchPage<ObjectHomePag
     }[];
     resolveSimilarRequest(similarRequest: ObjectHomePageRequest): ObjectHomePageRequest;
     getAlwaysRunRequests(): ObjectHomePageRequest[];
+    /**
+     * AlwaysRequests must be reduced with predictions.
+     *
+     * @returns true
+     */
+    shouldReduceAlwaysRequestsWithPredictions(): boolean;
+    /**
+     * In OH, the always requests are reduced with predictions, and because they
+     * can't be merged with other predictions, they will always run by themself.
+     * This value must be `false`, otherwise we may see repeated requests.
+     *
+     * @returns false
+     */
+    shouldExecuteAlwaysRequestByThemself(): boolean;
     static handlesContext(context: LexContext): context is ObjectHomePageContext;
 }

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

@@ -1,6 +1,6 @@
 import type { LexContext, LexPrefetcherOptions } from '../prefetcher';
 import type { GetRecordRequest, GetRecordsRequest, GetRecordRequestStrategy, GetRecordsRequestStrategy, GetRecordActionsRequestStrategy, GetRecordActionsRequest, GetRecordAvatarsRequest, GetRecordAvatarsRequestStrategy, GetObjectInfoRequest, GetObjectInfosRequest, GetObjectInfoRequestStrategy, GetObjectInfosRequestStrategy, GetRelatedListsActionsRequestStrategy, GetRelatedListsActionsRequest, GetRelatedListInfoBatchRequestStrategy, GetRelatedListInfoBatchRequest, GetRelatedListRecordsRequestStrategy, GetRelatedListRecordsRequest, GetRelatedListRecordsBatchRequestStrategy, GetRelatedListRecordsBatchRequest, GetApexRequest, GetComponentsRequest, GetApexRequestStrategy, GetComponentsDefStrategy } from '../request-strategy';
-import { PredictivePrefetchPage } from './predictive-prefetch-page';
+import { LexDefaultPage } from './lex-default-page';
 export type RecordHomePageContext = {
     objectApiName: string;
     recordId: string;
@@ -22,7 +22,7 @@ type RecordHomePageRequestStrategies = {
     getApex: GetApexRequestStrategy;
     getComponentsDef: GetComponentsDefStrategy;
 };
-export declare class RecordHomePage extends PredictivePrefetchPage<RecordHomePageRequest, RecordHomePageContext> {
+export declare class RecordHomePage extends LexDefaultPage<RecordHomePageRequest, RecordHomePageContext> {
     private requestStrategies;
     private options;
     similarContext: RecordHomePageContext;
@@ -33,6 +33,19 @@ export declare class RecordHomePage extends PredictivePrefetchPage<RecordHomePag
     }[];
     resolveSimilarRequest(similarRequest: RecordHomePageRequest): RecordHomePageRequest;
     getAlwaysRunRequests(): RecordHomePageRequest[];
+    /**
+     * In RH, we know that there will be predictions, and we want to reduce the always requests (getRecord(id, type))
+     * with one of the predictions in case some request containing the fields was missed in the predictions.
+     *
+     * @returns true
+     */
+    shouldReduceAlwaysRequestsWithPredictions(): boolean;
+    /**
+     * In RH, we should execute the getRecord(id, type) by itself as we want the result asap, so
+     * it does not stop rendering.
+     * @returns true
+     */
+    shouldExecuteAlwaysRequestByThemself(): boolean;
     static handlesContext(context: LexContext): context is RecordHomePageContext;
 }
 export {};

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

@@ -1,5 +1,6 @@
 import { ApplicationPredictivePrefetcher } from './predictive-prefetcher';
-import type { DefaultPageContext, PredictivePrefetchPage } from '../pages';
+import { LexDefaultPage } from '../pages/lex-default-page';
+import type { DefaultPageContext } from '../pages';
 import type { GetRecordActionsRequestStrategy, GetRecordAvatarsRequestStrategy, GetRecordRequestStrategy, GetRecordsRequestStrategy, GetObjectInfoRequestStrategy, GetObjectInfosRequestStrategy, GetRelatedListsActionsRequestStrategy, GetRelatedListInfoBatchRequestStrategy, GetRelatedListRecordsRequestStrategy, GetRelatedListRecordsBatchRequestStrategy, GetListInfoByNameRequestStrategy, GetListRecordsByNameRequestStrategy, GetApexRequestStrategy, GetComponentsDefStrategy, GetListInfosByObjectNameRequestStrategy, GetListObjectInfoRequestStrategy } from '../request-strategy';
 import type { RequestRunner } from '../request-runner';
 import type { PrefetchRepository } from '../repository/prefetch-repository';
@@ -25,6 +26,7 @@ export type LexPrefetcherOptions = {
 export declare class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher<LexRequest, LexContext> {
     private requestStrategies;
     protected options: LexPrefetcherOptions;
+    page: LexDefaultPage<LexRequest, LexContext>;
     constructor(context: LexContext, repository: PrefetchRepository, requestRunner: RequestRunner<LexRequest>, requestStrategies: {
         getRecord: GetRecordRequestStrategy;
         getRecords: GetRecordsRequestStrategy;
@@ -43,7 +45,7 @@ export declare class LexPredictivePrefetcher extends ApplicationPredictivePrefet
         getApex: GetApexRequestStrategy;
         getComponentsDef: GetComponentsDefStrategy;
     }, options: LexPrefetcherOptions);
-    getPage(): PredictivePrefetchPage<LexRequest, LexContext>;
+    getPage(): LexDefaultPage<LexRequest, LexContext>;
     getAllPageRequests(): RequestEntry<LexRequest>[];
     predict(): Promise<void>;
 }

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

@@ -1,5 +1,3 @@
-export declare const ObjectPrototypeHasOwnProperty: (v: PropertyKey) => boolean;
-export declare const ArrayIsArray: (arg: any) => arg is any[];
 /**
  * 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:

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

@@ -1,5 +1,5 @@
 import type { ApexInvokerParams } from '@salesforce/lds-adapters-apex';
-import type { Luvio } from '@luvio/engine';
+import type { AdapterRequestContext, Luvio, Snapshot } from '@luvio/engine';
 import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
 export type GetApexConfig = {
     name: string;
@@ -10,11 +10,12 @@ export type GetApexRequest = {
     adapterName: 'getApex';
     config: GetApexConfig;
 };
-export declare function getApexPdlFactory(luvio: Luvio): ({ invokerParams, config }: GetApexConfig) => import("@luvio/engine").Snapshot<any> | Promise<import("@luvio/engine").Snapshot<any>> | null;
+export declare function getApexPdlFactory(luvio: Luvio): ({ invokerParams, config }: GetApexConfig, requestContext?: AdapterRequestContext) => Snapshot<any> | Promise<Snapshot<any>> | null;
 type GetApexContext = Record<string, unknown>;
 export declare class GetApexRequestStrategy extends LuvioAdapterRequestStrategy<GetApexConfig, GetApexRequest, GetApexContext> {
     adapterName: string;
     adapterFactory: typeof getApexPdlFactory;
     buildConcreteRequest(similarRequest: GetApexRequest): GetApexRequest;
+    execute(config: GetApexConfig, _requestContext?: AdapterRequestContext | undefined): Snapshot<any> | Promise<Snapshot<any>> | null;
 }
 export {};

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

@@ -1,6 +1,16 @@
 import type { AdapterFactory, AdapterRequestContext, Luvio, Snapshot } from '@luvio/engine';
 import type { BaseAdapterRequest } from './request-strategy';
 import { RequestStrategy } from './request-strategy';
+export declare const DEFAULT_RESOURCE_CONTEXT: {
+    sourceContext: {
+        tagName: string;
+        actionConfig: {
+            background: boolean;
+            hotspot: boolean;
+            longRunning: boolean;
+        };
+    };
+};
 export declare abstract class LuvioAdapterRequestStrategy<AdapterConfig, Request extends BaseAdapterRequest<AdapterConfig>, Context> extends RequestStrategy<AdapterConfig, Request, Context> {
     private luvio;
     constructor(luvio: Luvio);

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

@@ -1,4 +1,5 @@
-import { InMemoryPrefetchStorage, type PrefetchStorage } from '.';
+import { type PrefetchStorage } from '.';
+import { InMemoryPrefetchStorage } from './in-memory-prefetch-storage';
 import { type AuraStorage, type AuraStorageConfig } from '@salesforce/lds-aura-storage';
 export declare const DEFAULT_STORAGE_OPTIONS: {
     name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.303.0",
+    "version": "1.305.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -35,15 +35,15 @@
     },
     "devDependencies": {
         "@luvio/service-broker": "5.3.1",
-        "@salesforce/lds-adapters-apex": "^1.303.0",
-        "@salesforce/lds-adapters-uiapi": "^1.303.0",
+        "@salesforce/lds-adapters-apex": "^1.305.0",
+        "@salesforce/lds-adapters-uiapi": "^1.305.0",
         "@salesforce/lds-adapters-uiapi-lex": "^1.302.0",
-        "@salesforce/lds-ads-bridge": "^1.303.0",
-        "@salesforce/lds-aura-storage": "^1.303.0",
-        "@salesforce/lds-bindings": "^1.303.0",
-        "@salesforce/lds-instrumentation": "^1.303.0",
-        "@salesforce/lds-network-aura": "^1.303.0",
-        "@salesforce/lds-network-fetch-with-jwt": "^1.303.0"
+        "@salesforce/lds-ads-bridge": "^1.305.0",
+        "@salesforce/lds-aura-storage": "^1.305.0",
+        "@salesforce/lds-bindings": "^1.305.0",
+        "@salesforce/lds-instrumentation": "^1.305.0",
+        "@salesforce/lds-network-aura": "^1.305.0",
+        "@salesforce/lds-network-fetch-with-jwt": "^1.305.0"
     },
     "dependencies": {
         "@luvio/command-aura-network": "5.3.1",
@@ -52,6 +52,7 @@
         "@luvio/command-sse": "5.3.1",
         "@luvio/command-streaming": "5.3.1",
         "@luvio/network-adapter-composable": "0.156.3",
+        "@luvio/network-adapter-fetch": "0.156.3",
         "@luvio/runtime": "5.3.1",
         "@luvio/service-aura-network": "5.3.1",
         "@luvio/service-cache-inclusion-policy": "5.3.1",
@@ -63,15 +64,15 @@
         "@luvio/service-subscription": "5.3.1",
         "@luvio/service-type-registry": "5.3.1",
         "@luvio/utils": "5.3.1",
-        "@salesforce/lds-adapters-uiapi-lex": "^1.303.0"
+        "@salesforce/lds-adapters-uiapi-lex": "^1.305.0"
     },
     "luvioBundlesize": [
         {
             "path": "./dist/ldsEngineCreator.js",
             "maxSize": {
-                "none": "151 kB",
-                "min": "62 kB",
-                "compressed": "28 kB"
+                "none": "170 kB",
+                "min": "70 kB",
+                "compressed": "31 kB"
             }
         }
     ],

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

@@ -1,13 +0,0 @@
-declare const create: {
-    (o: object | null): any;
-    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
-}, keys: {
-    (o: object): string[];
-    (o: {}): string[];
-};
-declare const isArray: (arg: any) => arg is any[];
-declare const stringify: {
-    (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
-    (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
-};
-export { create as ObjectCreate, keys as ObjectKeys, isArray as ArrayIsArray, stringify as JSONStringify, };