@salesforce/lds-runtime-aura 1.402.0 → 1.403.0

package/dist/ldsEngineCreator.js

@@ -33,13 +33,13 @@ import { dispatchGlobalEvent, unstable_loadComponentDefs, executeGlobalControlle
 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 { ThirdPartyTracker } from 'instrumentation:thirdPartyTracker';
 import { markStart, markEnd, counter, registerCacheStats, perfStart, perfEnd, registerPeriodicLogger, interaction, timer } from 'instrumentation/service';
-import { pageScopedCache } from 'instrumentation/utility';
-import { instrument as instrument$2, generateRequestId as generateRequestId$1, setupLexNetworkAdapter, internalRequestTracker } from 'force/ldsNetworkFetch';
+import { instrument as instrument$2, setupLexNetworkAdapter, internalRequestTracker, generateRequestId as generateRequestId$1 } from 'force/ldsNetworkFetch';
 import { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR, instrument as instrument$3 } from 'force/ldsBindings';
 import { LRUCache, instrumentAdapter, instrumentLuvio, setupInstrumentation as setupInstrumentation$1, logObjectInfoChanged as logObjectInfoChanged$1, updatePercentileHistogramMetric, incrementCounterMetric, incrementGetRecordNotifyChangeAllowCount, incrementGetRecordNotifyChangeDropCount, incrementNotifyRecordUpdateAvailableAllowCount, incrementNotifyRecordUpdateAvailableDropCount, setLdsAdaptersUiapiInstrumentation, logError as logError$2, setLdsNetworkAdapterInstrumentation, incrementStateCreatedCount, executeAsyncActivity, METRIC_KEYS, onIdleDetected } from 'force/ldsInstrumentation';
 import { instrument as instrument$4 } from 'force/adsBridge';
 import { instrument as instrument$5 } from '@lwc/state';
 import { withRegistration, register, setDefaultLuvio } from 'force/ldsEngine';
+import { pageScopedCache } from 'instrumentation/utility';
 import { createStorage, clearStorages } from 'force/ldsStorage';
 import useHotspotLimit from '@salesforce/gate/lds.pdl.useHotspotLimit';
 import useHttpUiapiOneApp from '@salesforce/gate/lds.useHttpUiapiOneApp';
@@ -2666,7 +2666,7 @@ function buildServiceDescriptor$d(luvio) {
         },
     };
 }
-// version: 1.402.0-566b6c5389
+// version: 1.403.0-5476a05446
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -3004,7 +3004,7 @@ function buildServiceDescriptor$9(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.402.0-566b6c5389
+// version: 1.403.0-5476a05446
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -3935,6 +3935,46 @@ function buildServiceDescriptor$2() {
   };
 }
 
+function createLockerCompatibleWireConstructor(DelegateCtor) {
+    function Constructor(callback, sourceContext, options) {
+        const delegate = new DelegateCtor(callback, sourceContext, options);
+        this.connect = () => delegate.connect();
+        this.disconnect = () => delegate.disconnect();
+        this.update = (config, context) => delegate.update(config, context);
+    }
+    return Constructor;
+}
+function buildLWCWireBindingsServiceDescriptor() {
+    const base = buildServiceDescriptor$1();
+    const originalBind = base.service.bind.bind(base.service);
+    const bind = (...args) => {
+        const ctor = originalBind(...args);
+        return createLockerCompatibleWireConstructor(ctor);
+    };
+    return {
+        ...base,
+        service: {
+            ...base.service,
+            bind,
+        },
+    };
+}
+function buildLWCGraphQLWireBindingsServiceDescriptor() {
+    const base = buildServiceDescriptor$2();
+    const originalBind = base.service.bind.bind(base.service);
+    const bind = (...args) => {
+        const ctor = originalBind(...args);
+        return createLockerCompatibleWireConstructor(ctor);
+    };
+    return {
+        ...base,
+        service: {
+            ...base.service,
+            bind,
+        },
+    };
+}
+
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -4629,204 +4669,6 @@ function generateRequestId() {
 
 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";
 
-function buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger) {
-    return async (response) => {
-        if (response.status === 401) {
-            try {
-                const coercedResponse = (await coerceResponseToFetchResponse(response.clone()));
-                if (coercedResponse.body.errorCode === 'INVALID_SESSION_ID') {
-                    logger.warn(`Received ${response.status} status code from LEX runtime service`);
-                    // Fire the event asynchronously, similar to the legacy setTimeout pattern
-                    window.setTimeout(() => {
-                        dispatchGlobalEvent('aura:invalidSession');
-                    }, 0);
-                }
-            }
-            catch (error) {
-                logger.warn(`Error parsing response from LEX runtime service: ${error}`);
-            }
-        }
-        return response;
-    };
-}
-function buildLexRuntimeLuvioAuthExpirationRedirectResponseInterceptor() {
-    return async (response) => {
-        if (response.status === 401) {
-            if (response.body.errorCode === 'INVALID_SESSION_ID') {
-                window.setTimeout(() => {
-                    dispatchGlobalEvent('aura:invalidSession');
-                }, 0);
-            }
-        }
-        return response;
-    };
-}
-
-/**
- * Extracts the ErrorId from a server error response message.
- * Looks for pattern: "ErrorId if you contact support: 1033627214-37969 (-1272663771)"
- * Returns the numeric value in parentheses.
- *
- * @param responseBody The response body text to parse.
- * @returns The extracted error ID, or null if not found.
- */
-function extractErrorIdFromResponse(responseBody) {
-    try {
-        const parsed = JSON.parse(responseBody);
-        if (Array.isArray(parsed) && parsed.length > 0 && parsed[0].message) {
-            const message = parsed[0].message;
-            // Look for pattern: "ErrorId if you contact support: XXXXXX-XXXXX (YYYYY)"
-            const match = message.match(/ErrorId[^:]*:\s*[\d-]+\s*\((-?\d+)\)/);
-            if (match && match[1]) {
-                return parseInt(match[1], 10);
-            }
-        }
-    }
-    catch (e) {
-        // If parsing fails, return null to use fallback
-    }
-    return null;
-}
-/**
- * Generates a unique error ID for tracking specific error occurrences.
- * Used as fallback when server doesn't provide an ErrorId.
- *
- * @param idInput The input value to hash.
- * @returns A unique error ID in Salesforce-compatible numeric format.
- */
-function generateErrorId(idInput) {
-    let hash = 0;
-    if (!idInput || idInput.length === 0) {
-        return hash;
-    }
-    let i, chr;
-    for (i = 0; i < idInput.length; i++) {
-        chr = idInput.charCodeAt(i);
-        hash = (hash << 5) - hash + chr;
-        hash |= 0; // Convert to 32bit integer
-    }
-    return hash;
-}
-/**
- * Gets error ID from response body or generates a fallback.
- * Tries to extract server-provided ErrorId first, falls back to generated hash.
- *
- * @param responseBody The response body to parse.
- * @param status The HTTP status code (for fallback).
- * @param statusText The HTTP status text (for fallback, optional).
- * @returns A numeric error ID.
- */
-function getOrGenerateErrorId(responseBody, status, statusText) {
-    const extractedId = extractErrorIdFromResponse(responseBody);
-    if (extractedId !== null) {
-        return extractedId;
-    }
-    // Fallback to generated error ID using status and timestamp
-    // statusText is optional and may not always be present
-    const context = [status, statusText || '', Date.now()].join('|');
-    return generateErrorId(context);
-}
-function buildLexRuntime5xxStatusResponseInterceptor(logger) {
-    return async (response) => {
-        if (response.status >= 500 && response.status < 600) {
-            const internalLogMessage = `LEX runtime 5xx: ${response.status} ${response.statusText || ''}`.trim();
-            logger.warn(internalLogMessage);
-            const userMessage = 'A server error occurred. Please try again later.';
-            // Try to extract ErrorId from response body, fallback to generated ID
-            let errorId;
-            try {
-                const responseText = await response.clone().text();
-                errorId = getOrGenerateErrorId(responseText, response.status, response.statusText);
-            }
-            catch (e) {
-                // If reading response fails, use fallback
-                const context = [response.status, response.statusText, Date.now()].join('|');
-                errorId = generateErrorId(context);
-            }
-            // Create an error object similar to Aura's current shape for system errors
-            const error = {
-                message: userMessage,
-                severity: 'ALERT',
-                name: 'LEXRuntimeError',
-                stack: null,
-                handled: false,
-                reported: false,
-                id: errorId,
-            };
-            const evtArgs = {
-                message: error.message,
-                error: null,
-                auraError: error,
-            };
-            // Fire the event asynchronously, similar to the legacy setTimeout pattern
-            window.setTimeout(() => {
-                dispatchGlobalEvent('markup://aura:systemError', evtArgs);
-            }, 0);
-            // Throw a simple error to terminate the request completely
-            // The consumer has NOT opted in to handle 5xx errors, so we don't return any response
-            // The systemError event above will handle showing the gack dialog
-            throw new Error(error.message);
-        }
-        return response;
-    };
-}
-function buildLexRuntimeLuvio5xxStatusResponseInterceptor() {
-    return async (response) => {
-        if (response.status >= 500 && response.status < 600) {
-            const userMessage = 'A server error occurred. Please try again later.';
-            // Try to extract ErrorId from response body, fallback to generated ID
-            let errorId;
-            try {
-                const responseBody = response.body ? JSON.stringify(response.body) : '';
-                errorId = getOrGenerateErrorId(responseBody, response.status, response.statusText);
-            }
-            catch (e) {
-                // If reading response fails, use fallback
-                const context = [response.status, response.statusText, Date.now()].join('|');
-                errorId = generateErrorId(context);
-            }
-            // Create an error object similar to Aura's current shape for system errors
-            const error = {
-                message: userMessage,
-                severity: 'ALERT',
-                name: 'LEXRuntimeError',
-                stack: null,
-                handled: false,
-                reported: false,
-                id: errorId,
-            };
-            const evtArgs = {
-                message: error.message,
-                error: null,
-                auraError: error,
-            };
-            // Fire the event asynchronously, similar to the legacy setTimeout pattern
-            window.setTimeout(() => {
-                dispatchGlobalEvent('markup://aura:systemError', evtArgs);
-            }, 0);
-            // Throw a simple error to terminate the request completely
-            // The consumer has NOT opted in to handle 5xx errors, so we don't return any response
-            // The systemError event above will handle showing the gack dialog
-            throw new Error(error.message);
-        }
-        return response;
-    };
-}
-
-function buildPageScopedCacheRequestInterceptor() {
-    return async (fetchArgs) => {
-        const pageScopedCacheHeaders = {};
-        // Allow the instrumentation util to set up the header value on our "dummy" header object
-        pageScopedCache.addHeader(pageScopedCacheHeaders);
-        let returnedFetchArgs = fetchArgs;
-        // If it set a value, add it to our fetchParams
-        Object.entries(pageScopedCacheHeaders).forEach(([key, value]) => {
-            returnedFetchArgs = setHeader(key, value, returnedFetchArgs);
-        });
-        return resolvedPromiseLike$2(returnedFetchArgs);
-    };
-}
-
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -4865,7 +4707,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.402.0-566b6c5389
+// version: 1.403.0-5476a05446
 
 /**
  * Observability / Critical Availability Program (230+)
@@ -5689,24 +5531,187 @@ function buildLuvioPageScopedCacheRequestInterceptor() {
     };
 }
 
-const REQUEST_ID_KEY = 'X-SFDC-Request-Id';
-function buildRequestIdInterceptor() {
-    return async (fetchArgs) => {
-        fetchArgs = setHeader(REQUEST_ID_KEY, generateRequestId$1(), fetchArgs);
-        return resolvedPromiseLike$2(fetchArgs);
+function buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger) {
+    return async (response) => {
+        if (response.status === 401) {
+            try {
+                const coercedResponse = (await coerceResponseToFetchResponse(response.clone()));
+                if (coercedResponse.body.errorCode === 'INVALID_SESSION_ID') {
+                    logger.warn(`Received ${response.status} status code from LEX runtime service`);
+                    // Fire the event asynchronously, similar to the legacy setTimeout pattern
+                    window.setTimeout(() => {
+                        dispatchGlobalEvent('aura:invalidSession');
+                    }, 0);
+                }
+            }
+            catch (error) {
+                logger.warn(`Error parsing response from LEX runtime service: ${error}`);
+            }
+        }
+        return response;
     };
 }
-function buildLuvioRequestIdInterceptor() {
-    return (resourceRequest) => {
-        // Ensure headers object exists
-        if (!resourceRequest.headers) {
-            resourceRequest.headers = {};
+function buildLexRuntimeLuvioAuthExpirationRedirectResponseInterceptor() {
+    return async (response) => {
+        if (response.status === 401) {
+            if (response.body.errorCode === 'INVALID_SESSION_ID') {
+                window.setTimeout(() => {
+                    dispatchGlobalEvent('aura:invalidSession');
+                }, 0);
+            }
         }
-        // Don't overwrite request id header if it already exists
-        if (!resourceRequest.headers[REQUEST_ID_KEY]) {
-            resourceRequest.headers[REQUEST_ID_KEY] = generateRequestId$1();
+        return response;
+    };
+}
+
+/**
+ * Extracts the ErrorId from a server error response message.
+ * Looks for pattern: "ErrorId if you contact support: 1033627214-37969 (-1272663771)"
+ * Returns the numeric value in parentheses.
+ *
+ * @param responseBody The response body text to parse.
+ * @returns The extracted error ID, or null if not found.
+ */
+function extractErrorIdFromResponse(responseBody) {
+    try {
+        const parsed = JSON.parse(responseBody);
+        if (Array.isArray(parsed) && parsed.length > 0 && parsed[0].message) {
+            const message = parsed[0].message;
+            // Look for pattern: "ErrorId if you contact support: XXXXXX-XXXXX (YYYYY)"
+            const match = message.match(/ErrorId[^:]*:\s*[\d-]+\s*\((-?\d+)\)/);
+            if (match && match[1]) {
+                return parseInt(match[1], 10);
+            }
         }
-        return resolvedPromiseLike$2(resourceRequest);
+    }
+    catch (e) {
+        // If parsing fails, return null to use fallback
+    }
+    return null;
+}
+/**
+ * Generates a unique error ID for tracking specific error occurrences.
+ * Used as fallback when server doesn't provide an ErrorId.
+ *
+ * @param idInput The input value to hash.
+ * @returns A unique error ID in Salesforce-compatible numeric format.
+ */
+function generateErrorId(idInput) {
+    let hash = 0;
+    if (!idInput || idInput.length === 0) {
+        return hash;
+    }
+    let i, chr;
+    for (i = 0; i < idInput.length; i++) {
+        chr = idInput.charCodeAt(i);
+        hash = (hash << 5) - hash + chr;
+        hash |= 0; // Convert to 32bit integer
+    }
+    return hash;
+}
+/**
+ * Gets error ID from response body or generates a fallback.
+ * Tries to extract server-provided ErrorId first, falls back to generated hash.
+ *
+ * @param responseBody The response body to parse.
+ * @param status The HTTP status code (for fallback).
+ * @param statusText The HTTP status text (for fallback, optional).
+ * @returns A numeric error ID.
+ */
+function getOrGenerateErrorId(responseBody, status, statusText) {
+    const extractedId = extractErrorIdFromResponse(responseBody);
+    if (extractedId !== null) {
+        return extractedId;
+    }
+    // Fallback to generated error ID using status and timestamp
+    // statusText is optional and may not always be present
+    const context = [status, statusText || '', Date.now()].join('|');
+    return generateErrorId(context);
+}
+function buildLexRuntime5xxStatusResponseInterceptor(logger) {
+    return async (response) => {
+        if (response.status >= 500 && response.status < 600) {
+            const internalLogMessage = `LEX runtime 5xx: ${response.status} ${response.statusText || ''}`.trim();
+            logger.warn(internalLogMessage);
+            const userMessage = 'A server error occurred. Please try again later.';
+            // Try to extract ErrorId from response body, fallback to generated ID
+            let errorId;
+            try {
+                const responseText = await response.clone().text();
+                errorId = getOrGenerateErrorId(responseText, response.status, response.statusText);
+            }
+            catch (e) {
+                // If reading response fails, use fallback
+                const context = [response.status, response.statusText, Date.now()].join('|');
+                errorId = generateErrorId(context);
+            }
+            // Create an error object similar to Aura's current shape for system errors
+            const error = {
+                message: userMessage,
+                severity: 'ALERT',
+                name: 'LEXRuntimeError',
+                stack: null,
+                handled: false,
+                reported: false,
+                id: errorId,
+            };
+            const evtArgs = {
+                message: error.message,
+                error: null,
+                auraError: error,
+            };
+            // Fire the event asynchronously, similar to the legacy setTimeout pattern
+            window.setTimeout(() => {
+                dispatchGlobalEvent('markup://aura:systemError', evtArgs);
+            }, 0);
+            // Throw a simple error to terminate the request completely
+            // The consumer has NOT opted in to handle 5xx errors, so we don't return any response
+            // The systemError event above will handle showing the gack dialog
+            throw new Error(error.message);
+        }
+        return response;
+    };
+}
+function buildLexRuntimeLuvio5xxStatusResponseInterceptor() {
+    return async (response) => {
+        if (response.status >= 500 && response.status < 600) {
+            const userMessage = 'A server error occurred. Please try again later.';
+            // Try to extract ErrorId from response body, fallback to generated ID
+            let errorId;
+            try {
+                const responseBody = response.body ? JSON.stringify(response.body) : '';
+                errorId = getOrGenerateErrorId(responseBody, response.status, response.statusText);
+            }
+            catch (e) {
+                // If reading response fails, use fallback
+                const context = [response.status, response.statusText, Date.now()].join('|');
+                errorId = generateErrorId(context);
+            }
+            // Create an error object similar to Aura's current shape for system errors
+            const error = {
+                message: userMessage,
+                severity: 'ALERT',
+                name: 'LEXRuntimeError',
+                stack: null,
+                handled: false,
+                reported: false,
+                id: errorId,
+            };
+            const evtArgs = {
+                message: error.message,
+                error: null,
+                auraError: error,
+            };
+            // Fire the event asynchronously, similar to the legacy setTimeout pattern
+            window.setTimeout(() => {
+                dispatchGlobalEvent('markup://aura:systemError', evtArgs);
+            }, 0);
+            // Throw a simple error to terminate the request completely
+            // The consumer has NOT opted in to handle 5xx errors, so we don't return any response
+            // The systemError event above will handle showing the gack dialog
+            throw new Error(error.message);
+        }
+        return response;
     };
 }
 
@@ -5960,11 +5965,7 @@ const composedFetchNetworkAdapter = {
         return API_PATH_MATCHERS.some((matcher) => matcher.test(path));
     },
     adapter: setupLexNetworkAdapter(requestTracker, requestLogger, {
-        request: [
-            buildLuvioPageScopedCacheRequestInterceptor(),
-            buildLuvioRequestIdInterceptor(),
-            buildLuvioCsrfTokenInterceptor(),
-        ],
+        request: [buildLuvioPageScopedCacheRequestInterceptor(), buildLuvioCsrfTokenInterceptor()],
         response: [
             buildLexRuntimeLuvio5xxStatusResponseInterceptor(),
             buildLexRuntimeLuvioAuthExpirationRedirectResponseInterceptor(),
@@ -5972,6 +5973,77 @@ const composedFetchNetworkAdapter = {
     }),
 };
 
+function buildThirdPartyTrackerFinishInterceptor() {
+    return async (context) => {
+        if (context && context.instrumentationId) {
+            instrumentationTracker.markFinished(context.instrumentationId);
+        }
+    };
+}
+
+function buildThirdPartyTrackerRegisterInterceptor() {
+    return async (fetchArgs, context) => {
+        if (context && context.instrumentationId) {
+            instrumentationTracker.registerHandler(context.instrumentationId, 'onestore-inflight-network-request', () => {
+                // return false until we signal we are finished
+                return false;
+            });
+        }
+        return resolvedPromiseLike$2(fetchArgs);
+    };
+}
+
+function createInstrumentationIdContext() {
+    return () => ({
+        instrumentationId: generateRequestId$1(),
+    });
+}
+function createStartMark(requestId) {
+    const startMark = markStart('transport', 'request');
+    startMark.context = {
+        auraXHRId: requestId,
+        background: false,
+        actionDefs: ['lds-fetch'],
+        requestId,
+        requestLength: -1, // not known
+    };
+}
+
+function buildPageScopedCacheRequestInterceptor() {
+    return async (fetchArgs) => {
+        const pageScopedCacheHeaders = {};
+        // Allow the instrumentation util to set up the header value on our "dummy" header object
+        pageScopedCache.addHeader(pageScopedCacheHeaders);
+        let returnedFetchArgs = fetchArgs;
+        // If it set a value, add it to our fetchParams
+        Object.entries(pageScopedCacheHeaders).forEach(([key, value]) => {
+            returnedFetchArgs = setHeader(key, value, returnedFetchArgs);
+        });
+        return resolvedPromiseLike$2(returnedFetchArgs);
+    };
+}
+
+const SFDC_REQUEST_ID_KEY = 'X-SFDC-Request-Id';
+function buildTransportMarksSendInterceptor() {
+    return async (fetchArgs, context) => {
+        // First set the requestId header. If there's not context, it means we won't be able to track the mark and something is hosed, and so not worth even trying
+        if (context && context.instrumentationId) {
+            const requestId = context.instrumentationId;
+            fetchArgs = setHeader(SFDC_REQUEST_ID_KEY, requestId, fetchArgs);
+            createStartMark(requestId);
+        }
+        return resolvedPromiseLike$2(fetchArgs);
+    };
+}
+
+function buildTransportMarksReceiveInterceptor() {
+    return async (context) => {
+        if (context && context.instrumentationId) {
+            markEnd('transport', 'request', { auraXHRId: context.instrumentationId });
+        }
+    };
+}
+
 const DEFAULT_CONFIG$1 = {
     maxRetries: 1, // Only retry once after token refresh
 };
@@ -6075,15 +6147,21 @@ async function isCsrfError(response) {
 
 function buildLexRuntimeDefaultFetchServiceDescriptor(logger, retryService) {
     const fetchService = buildLexConnectFetchServiceDescriptor({
+        createContext: createInstrumentationIdContext(),
         request: [
+            buildThirdPartyTrackerRegisterInterceptor(),
             buildPageScopedCacheRequestInterceptor(),
-            buildRequestIdInterceptor(),
+            buildTransportMarksSendInterceptor(),
             buildCsrfTokenInterceptor(),
         ],
         response: [
             buildLexRuntime5xxStatusResponseInterceptor(logger),
             buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger),
         ],
+        finally: [
+            buildTransportMarksReceiveInterceptor(),
+            buildThirdPartyTrackerFinishInterceptor(),
+        ],
     }, retryService);
     return {
         ...fetchService,
@@ -6091,30 +6169,34 @@ function buildLexRuntimeDefaultFetchServiceDescriptor(logger, retryService) {
 }
 function buildLexRuntimeAllow5xxFetchServiceDescriptor(logger, retryService) {
     const fetchService = buildLexConnectFetchServiceDescriptor({
+        createContext: createInstrumentationIdContext(),
         request: [
+            buildThirdPartyTrackerRegisterInterceptor(),
             buildPageScopedCacheRequestInterceptor(),
-            buildRequestIdInterceptor(),
+            buildTransportMarksSendInterceptor(),
             buildCsrfTokenInterceptor(),
         ],
         response: [buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger)],
+        finally: [
+            buildTransportMarksReceiveInterceptor(),
+            buildThirdPartyTrackerFinishInterceptor(),
+        ],
     }, retryService);
     return {
         ...fetchService,
         tags: { interceptors: 'allow_500s' },
     };
 }
-function buildLexConnectFetchServiceDescriptor(interceptors = { request: [], response: [] }, retryService) {
+// Temporarily cloned from conduit fetch until the retry service is updated there
+function buildLexConnectFetchServiceDescriptor(interceptors = { request: [], response: [], finally: [] }, retryService) {
     return {
         type: 'fetch',
         version: '1.0',
         service: function (...args) {
-            const { request: requestInterceptors = [], response: responseInterceptors = [] } = interceptors;
-            const pending = requestInterceptors.reduce((previousPromise, interceptor) => previousPromise.then(interceptor), resolvedPromiseLike$2(args));
-            const trackerId = generateRequestId$1();
-            instrumentationTracker.registerHandler(trackerId, 'onestore-inflight-network-request', () => {
-                // return false until we signal we are finished
-                return false;
-            });
+            // Create context per request if factory is provided
+            const context = interceptors.createContext?.();
+            const { request: requestInterceptors = [], response: responseInterceptors = [], finally: finallyInterceptors = [], } = interceptors;
+            const pending = requestInterceptors.reduce((previousPromise, interceptor) => previousPromise.then((args) => interceptor(args, context)), resolvedPromiseLike$2(args));
             return Promise.resolve(pending)
                 .then((interceptedArgs) => {
                 if (retryService) {
@@ -6141,10 +6223,15 @@ function buildLexConnectFetchServiceDescriptor(interceptors = { request: [], res
                 return fetch(...interceptedArgs);
             })
                 .then((response) => {
-                return responseInterceptors.reduce((previousPromise, interceptor) => previousPromise.then(interceptor), resolvedPromiseLike$2(response));
+                // Success path - run response interceptors
+                return responseInterceptors.reduce((previousPromise, interceptor) => previousPromise.then((response) => interceptor(response, context)), resolvedPromiseLike$2(response));
             })
                 .finally(() => {
-                instrumentationTracker.markFinished(trackerId);
+                // Always run finally interceptors for cleanup
+                if (finallyInterceptors.length > 0) {
+                    // Run all finally interceptors sequentially
+                    return finallyInterceptors.reduce((previousPromise, interceptor) => previousPromise.then(() => interceptor(context)), Promise.resolve());
+                }
             });
         },
     };
@@ -6155,7 +6242,9 @@ const sfapJwtRepository = new JwtRepository();
 const sfapJwtManager = new JwtManager(sfapJwtRepository, platformSfapJwtResolver);
 function buildJwtAuthorizedSfapFetchServiceDescriptor(logger) {
     const jwtAuthorizedFetchService = buildLexConnectFetchServiceDescriptor({
-        request: [buildJwtRequestInterceptor(logger)],
+        createContext: createInstrumentationIdContext(),
+        request: [buildThirdPartyTrackerRegisterInterceptor(), buildJwtRequestInterceptor(logger)],
+        finally: [buildThirdPartyTrackerFinishInterceptor()],
     });
     return {
         ...jwtAuthorizedFetchService,
@@ -6174,7 +6263,9 @@ function buildCopilotFetchServiceDescriptor(logger) {
         // Interceptor here with the logic in buildJwtAuthorizedSfapFetchServiceDescriptor()
         // above.
         ...buildLexConnectFetchServiceDescriptor({
+            createContext: createInstrumentationIdContext(),
             request: [
+                buildThirdPartyTrackerRegisterInterceptor(),
                 // 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.
@@ -6214,12 +6305,17 @@ function buildCopilotFetchServiceDescriptor(logger) {
                 },
                 buildJwtRequestInterceptor(logger),
             ],
+            finally: [buildThirdPartyTrackerFinishInterceptor()],
         }),
         tags: { specialHacksFor: 'copilot' },
     };
 }
 function buildUnauthorizedFetchServiceDescriptor() {
-    const fetchService = buildLexConnectFetchServiceDescriptor();
+    const fetchService = buildLexConnectFetchServiceDescriptor({
+        createContext: createInstrumentationIdContext(),
+        request: [buildThirdPartyTrackerRegisterInterceptor()],
+        finally: [buildThirdPartyTrackerFinishInterceptor()],
+    });
     return {
         ...fetchService,
         tags: { authenticationScopes: '' },
@@ -9664,8 +9760,8 @@ function initializeOneStore(luvio) {
         buildServiceDescriptor$2$1(),
         buildServiceDescriptor$1$1(),
         buildServiceDescriptor$7(),
-        buildServiceDescriptor$1(),
-        buildServiceDescriptor$2(),
+        buildLWCWireBindingsServiceDescriptor(),
+        buildLWCGraphQLWireBindingsServiceDescriptor(),
     ];
     setServices(services);
 }
@@ -9685,4 +9781,4 @@ function ldsEngineCreator() {
 }
 
 export { LexRequestStrategy, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, notifyUpdateAvailableFactory, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.402.0-bf9ae185ef
+// version: 1.403.0-bc09fbc54b

package/dist/types/__mocks__/instrumentation/service.d.ts

@@ -10,8 +10,8 @@ export declare function gauge(): {
     reset(): void;
 };
 export declare function mark(): void;
-export declare function markStart(): void;
-export declare function markEnd(): void;
+export declare function markStart(): {};
+export declare function markEnd(): {};
 export declare function perfStart(): void;
 export declare function perfEnd(): void;
 export declare function percentileHistogram(): {

package/dist/types/fetch-service-descriptors/lex-fetch-service.d.ts

@@ -3,4 +3,4 @@ import { Interceptors, type FetchServiceDescriptor } from '@conduit-client/servi
 import { RetryService } from '@conduit-client/service-retry/v1';
 export declare function buildLexRuntimeDefaultFetchServiceDescriptor(logger: LoggerService, retryService?: RetryService<Response>): FetchServiceDescriptor;
 export declare function buildLexRuntimeAllow5xxFetchServiceDescriptor(logger: LoggerService, retryService?: RetryService<Response>): FetchServiceDescriptor;
-export declare function buildLexConnectFetchServiceDescriptor(interceptors?: Interceptors, retryService?: RetryService<Response>): FetchServiceDescriptor;
+export declare function buildLexConnectFetchServiceDescriptor<Context = any>(interceptors?: Interceptors<Context>, retryService?: RetryService<Response>): FetchServiceDescriptor;

package/dist/types/finally-interceptors/third-party-tracker-finish.d.ts

@@ -0,0 +1,2 @@
+import { FinallyInterceptor } from '@conduit-client/service-fetch-network/v1';
+export declare function buildThirdPartyTrackerFinishInterceptor(): FinallyInterceptor;

package/dist/types/finally-interceptors/transport-receive.d.ts

@@ -0,0 +1,3 @@
+import { FinallyInterceptor } from '@conduit-client/service-fetch-network/v1';
+export declare function buildTransportMarksReceiveInterceptor(): FinallyInterceptor;
+export declare function buildLuvioTransportMarksReceiveInterceptor(): FinallyInterceptor;

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

@@ -0,0 +1,4 @@
+export declare function createInstrumentationIdContext(): () => {
+    instrumentationId: string;
+};
+export declare function createStartMark(requestId: string): void;

package/dist/types/locker-wire-bindings.d.ts

@@ -0,0 +1,3 @@
+import type { LWCWireBindingsServiceDescriptor, LWCGraphQLWireBindingsServiceDescriptor } from '@conduit-client/service-bindings-lwc/v1';
+export declare function buildLWCWireBindingsServiceDescriptor(): LWCWireBindingsServiceDescriptor;
+export declare function buildLWCGraphQLWireBindingsServiceDescriptor(): LWCGraphQLWireBindingsServiceDescriptor;

package/dist/types/request-interceptors/third-party-tracker-register.d.ts

@@ -0,0 +1,2 @@
+import { RequestInterceptor } from '@conduit-client/service-fetch-network/v1';
+export declare function buildThirdPartyTrackerRegisterInterceptor(): RequestInterceptor;

package/dist/types/request-interceptors/transport-send.d.ts

@@ -0,0 +1,5 @@
+import { RequestInterceptor } from '@conduit-client/service-fetch-network/v1';
+import { ResourceRequest } from '@luvio/engine';
+export declare const SFDC_REQUEST_ID_KEY = "X-SFDC-Request-Id";
+export declare function buildTransportMarksSendInterceptor(): RequestInterceptor;
+export declare function buildLuvioTransportMarksSendInterceptor(): (resourceRequest: ResourceRequest, context?: any) => PromiseLike<ResourceRequest>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.402.0",
+    "version": "1.403.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -36,14 +36,14 @@
     "devDependencies": {
         "@conduit-client/service-provisioner": "3.2.0",
         "@conduit-client/tools-core": "3.2.0",
-        "@salesforce/lds-adapters-apex": "^1.402.0",
-        "@salesforce/lds-adapters-uiapi": "^1.402.0",
-        "@salesforce/lds-ads-bridge": "^1.402.0",
-        "@salesforce/lds-aura-storage": "^1.402.0",
-        "@salesforce/lds-bindings": "^1.402.0",
-        "@salesforce/lds-instrumentation": "^1.402.0",
-        "@salesforce/lds-network-aura": "^1.402.0",
-        "@salesforce/lds-network-fetch": "^1.402.0",
+        "@salesforce/lds-adapters-apex": "^1.403.0",
+        "@salesforce/lds-adapters-uiapi": "^1.403.0",
+        "@salesforce/lds-ads-bridge": "^1.403.0",
+        "@salesforce/lds-aura-storage": "^1.403.0",
+        "@salesforce/lds-bindings": "^1.403.0",
+        "@salesforce/lds-instrumentation": "^1.403.0",
+        "@salesforce/lds-network-aura": "^1.403.0",
+        "@salesforce/lds-network-fetch": "^1.403.0",
         "jwt-encode": "1.0.1"
     },
     "dependencies": {
@@ -71,10 +71,10 @@
         "@luvio/network-adapter-composable": "0.158.7",
         "@luvio/network-adapter-fetch": "0.158.7",
         "@lwc/state": "^0.23.0",
-        "@salesforce/lds-adapters-onestore-graphql": "^1.402.0",
-        "@salesforce/lds-adapters-uiapi-lex": "^1.402.0",
-        "@salesforce/lds-luvio-service": "^1.402.0",
-        "@salesforce/lds-luvio-uiapi-records-service": "^1.402.0"
+        "@salesforce/lds-adapters-onestore-graphql": "^1.403.0",
+        "@salesforce/lds-adapters-uiapi-lex": "^1.403.0",
+        "@salesforce/lds-luvio-service": "^1.403.0",
+        "@salesforce/lds-luvio-uiapi-records-service": "^1.403.0"
     },
     "luvioBundlesize": [
         {

package/dist/types/request-interceptors/request-id.d.ts

@@ -1,4 +0,0 @@
-import { RequestInterceptor } from '@conduit-client/service-fetch-network/v1';
-import { ResourceRequest } from '@luvio/engine';
-export declare function buildRequestIdInterceptor(): RequestInterceptor;
-export declare function buildLuvioRequestIdInterceptor(): (resourceRequest: ResourceRequest) => PromiseLike<ResourceRequest>;