@salesforce/lds-runtime-aura 1.412.1 → 1.414.1

package/dist/ldsEngineCreator.js

@@ -18,7 +18,6 @@ import usePredictiveLoading from '@salesforce/gate/lds.usePredictiveLoading';
 import useApexPredictions from '@salesforce/gate/lds.pdl.useApexPredictions';
 import useRelatedListsPredictions from '@salesforce/gate/lds.pdl.useRelatedListsPredictions';
 import useRelatedListPlus from '@salesforce/gate/lds.pdl.useRelatedListPlus';
-import applyPredictionRequestLimit from '@salesforce/gate/lds.pdl.applyRequestLimit';
 import useLocalStorage from '@salesforce/gate/lds.pdl.useLocalStorage';
 import useOneStoreGraphql from '@salesforce/gate/lds.oneStoreGraphqlEnabled.ltng';
 import canCombineRecordLayoutRequests from '@salesforce/gate/lds.pdl.canCombineRecordLayoutRequests';
@@ -26,19 +25,20 @@ import { GetApexWireAdapterFactory, registerPrefetcher as registerPrefetcher$1 }
 import { instrument, getRecordAvatarsAdapterFactory, getRecordAdapterFactory, coerceFieldIdArray, coerceLayoutTypeArray, coerceLayoutModeArray, getRecordsAdapterFactory, getRecordActionsAdapterFactory, getObjectInfosAdapterFactory, coerceObjectIdArray, getObjectInfoAdapterFactory, coerceObjectId, getRelatedListsActionsAdapterFactory, getRelatedListInfoBatchAdapterFactory, getRelatedListInfoAdapterFactory, getRelatedListRecordsBatchAdapterFactory, getRelatedListRecordsAdapterFactory, getListInfoByNameAdapterFactory, getListInfosByObjectNameAdapterFactory, getListRecordsByNameAdapterFactory, getListObjectInfoAdapterFactory, getRelatedListsInfoAdapterFactory, getRelatedListActionsAdapterFactory, getRecordId18Array, buildRecordRepKeyFromId, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType, registerPrefetcher, RecordRepresentationVersion } from 'force/ldsAdaptersUiapi';
 import { getInstrumentation } from 'o11y/client';
 import { findExecutableOperation, buildGraphQLInputExtension, addTypenameToDocument } from 'force/luvioGraphqlNormalization';
-import { print, wrapConfigAndVerify, resolveAst, validateGraphQLOperations } from 'force/luvioOnestoreGraphqlParser';
+import { print, resolveAndValidateGraphQLConfig } from 'force/luvioOnestoreGraphqlParser';
 import { setServices } from 'force/luvioServiceProvisioner1';
 import { assertIsValid, MissingRequiredPropertyError, JsonSchemaViolationError } from 'force/luvioJsonschemaValidate5';
 import { dispatchGlobalEvent, unstable_loadComponentDefs, executeGlobalControllerRawResponse } from 'aura';
 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 { instrument as instrument$2, setupLexNetworkAdapter, internalRequestTracker, generateRequestId as generateRequestId$1 } from 'force/ldsNetworkFetch';
+import { instrument as instrument$2, setupLexNetworkAdapter } 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 { LRUCache, instrumentAdapter, instrumentLuvio, logMessage as logMessage$1, 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 applyPredictionRequestLimit from '@salesforce/gate/lds.pdl.applyRequestLimit';
 import { pageScopedCache } from 'instrumentation/utility';
 import { createStorage, clearStorages } from 'force/ldsStorage';
 import lightningConnectEnabled from '@salesforce/gate/ui.services.LightningConnect.enabled';
@@ -411,7 +411,10 @@ class AuraNetworkCommand extends NetworkCommand$1 {
   coerceAuraErrors(auraErrors) {
     return toError(auraErrors[0]);
   }
-  async coerceFetchErrors(errorResponse) {
+  /**
+   * Customize how non-2xx fetch fallback responses are converted into errors.
+   */
+  async coerceError(errorResponse) {
     return toError(errorResponse.statusText);
   }
   convertAuraResponseToData(responsePromise, coerceError) {
@@ -449,7 +452,7 @@ class AuraNetworkCommand extends NetworkCommand$1 {
             }
           });
         } else {
-          return this.coerceFetchErrors(response2).then((coercedError) => {
+          return this.coerceError(response2).then((coercedError) => {
             return err$1(coercedError);
           }).finally(() => {
             try {
@@ -1090,7 +1093,7 @@ let AuraCacheControlCommand$1 = class AuraCacheControlCommand extends CacheContr
   coerceAuraErrors(auraErrors) {
     return toError(auraErrors[0]);
   }
-  async coerceFetchError(errorResponse) {
+  async coerceError(errorResponse) {
     return toError(errorResponse.statusText);
   }
   processAuraReturnValue(auraReturnValue) {
@@ -1136,7 +1139,7 @@ let AuraCacheControlCommand$1 = class AuraCacheControlCommand extends CacheContr
             }
           });
         } else {
-          return this.coerceFetchError(response2).then((coercedError) => {
+          return this.coerceError(response2).then((coercedError) => {
             return err$1(coercedError);
           }).finally(() => {
             try {
@@ -1238,7 +1241,7 @@ class AuraCacheControlCommand extends CacheControlCommand {
   coerceAuraErrors(auraErrors) {
     return toError(auraErrors[0]);
   }
-  async coerceFetchError(errorResponse) {
+  async coerceError(errorResponse) {
     return toError(errorResponse.statusText);
   }
   processAuraReturnValue(auraReturnValue) {
@@ -1284,7 +1287,7 @@ class AuraCacheControlCommand extends CacheControlCommand {
             }
           });
         } else {
-          return this.coerceFetchError(response2).then((coercedError) => {
+          return this.coerceError(response2).then((coercedError) => {
             return err$1(coercedError);
           }).finally(() => {
             try {
@@ -2702,7 +2705,7 @@ function buildServiceDescriptor$d(luvio) {
         },
     };
 }
-// version: 1.412.1-944b7de7af
+// version: 1.414.1-06354ce124
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -3055,7 +3058,7 @@ function buildServiceDescriptor$9(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.412.1-944b7de7af
+// version: 1.414.1-06354ce124
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -3437,7 +3440,7 @@ class LegacyImperativeBindingsService {
     return { invoke, subscribe };
   }
 }
-function buildServiceDescriptor$3() {
+function buildServiceDescriptor$3$1() {
   return {
     type: "legacyImperativeBindings",
     version: "1.0",
@@ -3449,7 +3452,16 @@ class GraphQLImperativeBindingsService {
     return async (...params) => {
       try {
         if (params.length) {
-          params[0] = wrapConfigAndVerify(params[0]);
+          const options = {
+            acceptedOperations: ["query"]
+          };
+          const result = resolveAndValidateGraphQLConfig(params[0], options);
+          if (result == null ? void 0 : result.isErr()) {
+            return result.error;
+          }
+          if (result == null ? void 0 : result.isOk()) {
+            params[0] = result.value;
+          }
         }
         return await buildBaseImperativeInvoker(getCommand, (result) => this.transformResult(result, exposeRefresh))(...params);
       } catch (error) {
@@ -3540,7 +3552,19 @@ function buildServiceDescriptor$2$1() {
 class GraphQLLegacyImperativeBindingsService {
   bind(getCommand) {
     const invoke = async (config, requestContext, callback) => {
-      config = wrapConfigAndVerify(config);
+      if (config) {
+        const options = {
+          acceptedOperations: ["query"]
+        };
+        const result = resolveAndValidateGraphQLConfig(config, options);
+        if (result == null ? void 0 : result.isErr()) {
+          callback(result.error);
+          return;
+        }
+        if (result == null ? void 0 : result.isOk()) {
+          config = result.value;
+        }
+      }
       const command = getCommand({ config, assertIsValid });
       try {
         const overrides = getOverridesForLegacyRequestContext(requestContext);
@@ -3569,7 +3593,20 @@ class GraphQLLegacyImperativeBindingsService {
       }
     };
     const subscribe = (config, requestContext, callback) => {
-      config = wrapConfigAndVerify(config);
+      if (config) {
+        const options = {
+          acceptedOperations: ["query"]
+        };
+        const result = resolveAndValidateGraphQLConfig(config, options);
+        if (result == null ? void 0 : result.isErr()) {
+          callback(result.error);
+          return () => {
+          };
+        }
+        if (result == null ? void 0 : result.isOk()) {
+          config = result.value;
+        }
+      }
       const command = getCommand({ config, assertIsValid });
       let unsubscribe = () => {
       };
@@ -3618,9 +3655,19 @@ class GraphQLMutationBindingsService {
     return async (...params) => {
       try {
         if (params.length) {
-          params[0] = wrapConfigAndVerify(params[0], {
+          const options = {
             acceptedOperations: ["mutation"]
-          });
+          };
+          const result2 = resolveAndValidateGraphQLConfig(params[0], options);
+          if (result2 == null ? void 0 : result2.isErr()) {
+            return {
+              data: void 0,
+              errors: result2.error.errors
+            };
+          }
+          if (result2 == null ? void 0 : result2.isOk()) {
+            params[0] = result2.value;
+          }
         }
         const command = getCommand({ params, assertIsValid });
         const result = await command.execute({ cacheControlConfig: { type: "no-cache" } });
@@ -3950,16 +3997,25 @@ class GraphQLCommandWireAdapterConstructor extends CommandWireAdapterConstructor
   }
   update(config, _context) {
     this.unsubscribe();
-    const resolvedQuery = resolveAst(config.query);
-    if (resolvedQuery) {
-      validateGraphQLOperations(
-        { query: resolvedQuery, operationName: config == null ? void 0 : config.operationName },
-        { acceptedOperations: ["query"] }
-      );
+    const options = {
+      acceptedOperations: ["query"]
+    };
+    const result = resolveAndValidateGraphQLConfig(config, options);
+    if (!result) {
+      return;
     }
+    if (result.isErr()) {
+      const error = result.error;
+      this.callback({
+        data: void 0,
+        errors: error.errors
+      });
+      return;
+    }
+    const { query, ...rest } = result.value;
     this.config = {
-      ...sanitize(config),
-      query: resolvedQuery
+      query,
+      ...sanitize(rest)
     };
     this.invokeAdapter();
   }
@@ -3978,7 +4034,7 @@ class LWCGraphQLWireBindingsService {
     };
   }
 }
-function buildServiceDescriptor$2() {
+function buildServiceDescriptor$3() {
   return {
     type: "lwcGraphQLWireBindings",
     version: "1.0",
@@ -4011,7 +4067,7 @@ function buildLWCWireBindingsServiceDescriptor() {
     };
 }
 function buildLWCGraphQLWireBindingsServiceDescriptor() {
-    const base = buildServiceDescriptor$2();
+    const base = buildServiceDescriptor$3();
     const originalBind = base.service.bind.bind(base.service);
     const bind = (...args) => {
         const ctor = originalBind(...args);
@@ -4321,7 +4377,7 @@ class JwtManager {
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-function buildServiceDescriptor$1(interceptors = {
+function buildServiceDescriptor$2(interceptors = {
   request: [],
   retry: void 0,
   response: [],
@@ -4714,7 +4770,7 @@ const sfapNetworkAdapter = async (resourceRequest, resourceRequestContext) => {
     authenticatedRequest = modifySfapResourceRequest(authenticatedRequest, jwtToken);
     // --- instrumentation block --- start
     const uniqueRequestTaskIdentifier = 'sfap-' + sfapRequestCount++;
-    const uniqueRequestGuid = generateRequestId();
+    const uniqueRequestGuid = generateRequestId$1();
     // request id header allows logging the request id and searching for the request logs
     authenticatedRequest.headers[X_REQUEST_ID_HEADER] = uniqueRequestGuid;
     let fetchComplete = false;
@@ -4753,7 +4809,7 @@ const composedNetworkAdapter$1 = {
     },
     adapter: sfapNetworkAdapter,
 };
-function generateRequestId() {
+function generateRequestId$1() {
     if (typeof crypto !== 'undefined' && crypto.randomUUID) {
         // as nov. 2025 caniuse says this has 93.5% support (all modern browsers)
         return crypto.randomUUID();
@@ -4767,46 +4823,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";
 
-/**
- * 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.412.1-944b7de7af
-
 /**
  * Observability / Critical Availability Program (230+)
  *
@@ -5288,6 +5304,9 @@ function incrementRequestResponseCount(cb) {
 function logObjectInfoChanged() {
     logObjectInfoChanged$1();
 }
+function logMessage(message) {
+    logMessage$1(message);
+}
 /**
  * Create a new instrumentation cache stats and return it.
  *
@@ -5395,7 +5414,205 @@ function logCRUDLightningInteraction(eventSource, attributes) {
 }
 const instrumentation = new Instrumentation();
 
-const forceRecordTransactionsDisabled = getEnvironmentSetting(EnvironmentSettings.ForceRecordTransactionsDisabled);
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+function valueFor(value, path) {
+  if (path.length === 0 || path[0] === "") {
+    return value;
+  } else if (value === null || typeof value !== "object") {
+    return void 0;
+  } else if (Array.isArray(value)) {
+    const index = parseInt(path[0]);
+    if (index >= 0) {
+      return valueFor(value[index], path.slice(1));
+    }
+    return void 0;
+  } else {
+    return valueFor(value[path[0]], path.slice(1));
+  }
+}
+class PrioritizedConfigService {
+  constructor(initialConfigDatas) {
+    this.validators = [];
+    this.validated = false;
+    this.readonlyObjectProxies = /* @__PURE__ */ new Map();
+    this.unsafeConfig = this.buildReadonlyObjectProxy([]);
+    this.prioritizedConfigData = {};
+    for (const [p, initialConfigData] of Object.entries(initialConfigDatas)) {
+      this.prioritizedConfigData[p] = initialConfigData || {};
+    }
+  }
+  // ConfigService.addValidator
+  addValidator(validator) {
+    this.validators.push(validator);
+    this.validated = false;
+  }
+  // ConfigService.validate
+  validate() {
+    const errors = [];
+    this.validators.forEach((v) => {
+      const result = v(this.unsafeConfig);
+      if (result.isErr()) {
+        errors.push(...result.error);
+      }
+    });
+    this.validated = errors.length === 0;
+    return errors.length === 0 ? ok$2(void 0) : err$1(errors);
+  }
+  // constructs a proxy for the given non-leaf object path in the config tree
+  buildReadonlyObjectProxy(path) {
+    const key = path.join("\0");
+    let proxy = this.readonlyObjectProxies.get(key);
+    if (proxy) {
+      return proxy;
+    }
+    proxy = new Proxy(/* @__PURE__ */ Object.create(null), {
+      defineProperty: () => {
+        throw new Error("cannot (re)define properties on config");
+      },
+      deleteProperty: () => {
+        throw new Error("cannot delete properties on config");
+      },
+      get: (_, property) => {
+        const propertyPath = [...path, property];
+        const value = this.valueFor(propertyPath);
+        return typeof value === "object" && value !== null && !isArray$3(value) ? this.buildReadonlyObjectProxy(propertyPath) : value;
+      },
+      getOwnPropertyDescriptor: (target, property) => {
+        const propertyPath = [...path, property];
+        const value = this.valueFor(propertyPath);
+        return {
+          value: (
+            // TODO - need to wrap arrays in a Proxy as well
+            typeof value === "object" && value !== null && !isArray$3(value) ? this.buildReadonlyObjectProxy(propertyPath) : value
+          ),
+          writable: false,
+          configurable: true,
+          enumerable: true
+        };
+      },
+      has: (_, property) => {
+        return this.valueFor([...path, property]) !== void 0;
+      },
+      ownKeys: () => {
+        const keys = [];
+        for (const v of Object.values(this.prioritizedConfigData)) {
+          const value = valueFor(v, path);
+          if (value) {
+            keys.push(...Object.keys(value));
+          }
+        }
+        return [...new Set(keys)];
+      },
+      set: () => {
+        throw new Error("cannot directly set values on config");
+      }
+    });
+    this.readonlyObjectProxies.set(key, proxy);
+    return proxy;
+  }
+  // ConfigService.config
+  get config() {
+    if (!this.validated) {
+      const result = this.validate();
+      if (result.isErr()) {
+        throw result.error.join("; ");
+      }
+    }
+    return this.unsafeConfig;
+  }
+  // ConfigService.set
+  set(priority, setter) {
+    this.validated = false;
+    return setter(this.prioritizedConfigData[priority]);
+  }
+  // returns the highest priority value for a given path, undefined if no value
+  // is defined for the path at any priority
+  valueFor(path) {
+    for (const [_, data] of Object.entries(this.prioritizedConfigData)) {
+      const value = valueFor(data, path);
+      if (value !== void 0) {
+        return value;
+      }
+    }
+  }
+}
+function buildServiceDescriptor$1(initialConfigDatas) {
+  return {
+    type: "config",
+    version: "1.0",
+    service: new PrioritizedConfigService(initialConfigDatas)
+  };
+}
+
+/**
+ * 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.414.1-06354ce124
+
+const environmentHasAura = typeof window !== 'undefined' && typeof window.$A !== 'undefined';
+const defaultConfig = {
+    maxAllowedParallelXHRCounts: 9,
+    forceRecordTransactionsDisabled: false,
+};
+const configServiceDescriptor = buildServiceDescriptor$1({
+    overrides: {},
+    lex: {},
+    default: defaultConfig,
+});
+const configService = configServiceDescriptor.service;
+if (environmentHasAura) {
+    configService.set('lex', (config) => {
+        config.maxAllowedParallelXHRCounts =
+            window['$A'].clientService.maxAllowedParallelXHRCounts();
+        config.forceRecordTransactionsDisabled = getEnvironmentSetting(EnvironmentSettings.ForceRecordTransactionsDisabled);
+    });
+}
+if (!applyPredictionRequestLimit.isOpen({ fallback: false })) {
+    configService.set('lex', (config) => {
+        config.maxAllowedParallelXHRCounts = 1000;
+    });
+}
+
+const forceRecordTransactionsDisabled = configService.config.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';
@@ -5815,7 +6032,7 @@ function buildLexRuntimeLuvio5xxStatusResponseInterceptor() {
 
 const CSRF_TOKEN_KEY = 'salesforce_csrf_token';
 const CSRF_STORAGE_NAME = 'ldsCSRFToken';
-const BASE_URI = '/services/data/v66.0';
+const BASE_URI = '/services/data/v67.0';
 const UI_API_BASE_URI = `${BASE_URI}/ui-api`;
 const CSRF_TOKEN_ENDPOINT = `${UI_API_BASE_URI}/session/csrf`;
 const CSRF_STORAGE_CONFIG = {
@@ -6034,6 +6251,191 @@ function buildLuvioCsrfTokenInterceptor() {
     };
 }
 
+function createInstrumentationIdContext() {
+    return () => ({
+        instrumentationId: generateRequestId(),
+    });
+}
+function createStartMark(requestId) {
+    const startMark = markStart('transport', 'request');
+    startMark.context = {
+        auraXHRId: requestId,
+        background: false,
+        actionDefs: ['lds-fetch'],
+        requestId,
+        requestLength: -1, // not known
+    };
+}
+function createEndMark(responseStatus, responseStatusText, url, context, errorMessage) {
+    if (context && context.instrumentationId) {
+        const endMark = markEnd('transport', 'request', { auraXHRId: context.instrumentationId });
+        if (performance && performance.getEntriesByName) {
+            const resources = performance.getEntriesByName(url);
+            let resource;
+            if (resources.length) {
+                if (resources.length === 1) {
+                    // only one, so it is the correct one
+                    resource = resources[0];
+                }
+                else {
+                    // otherwise we need to guess based on the start time
+                    resource = findCorrectResource(resources, context);
+                }
+                if (resource) {
+                    setResourceTimings(context.instrumentationId, responseStatus, responseStatusText, endMark, resource);
+                }
+            }
+            else if (errorMessage) {
+                logMessage(errorMessage);
+            }
+        }
+    }
+}
+// noop implementation for when one is not provided
+let internalRequestTracker = {
+    hasTracker: () => false,
+    registerHandler: (_request, _name, _loadedCheck) => { },
+    markFinished: (_request) => { },
+};
+function setResourceTimings(id, responseStatus, responseStatusText, endMark, r) {
+    endMark.context = {
+        auraXHRId: id,
+        status: responseStatus,
+        statusText: responseStatusText,
+        // Timings fields
+        responseLength: r.decodedBodySize || 0,
+        serverTime: r.serverTiming || 0,
+        xhrDuration: Math.floor(r.responseEnd - r.startTime),
+        xhrStall: Math.floor(r.requestStart - r.startTime),
+        startTime: Math.floor(r.startTime),
+        fetchStart: Math.floor(r.fetchStart),
+        requestStart: Math.floor(r.requestStart),
+        dns: Math.floor(r.domainLookupEnd - r.domainLookupStart),
+        tcp: Math.floor(r.connectEnd - r.connectStart),
+        ttfb: Math.floor(r.responseStart - r.startTime),
+        transfer: Math.floor(r.responseEnd - r.responseStart),
+        transferSize: r['transferSize'] || 0,
+        nextHopProtocol: r['nextHopProtocol'],
+    };
+}
+function findCorrectResource(resources, context) {
+    if (context && context.startTime) {
+        let likelyResource = {
+            index: 0,
+            diff: Math.abs(context.startTime - resources[0].startTime),
+        };
+        for (let entry = 1; entry < resources.length; ++entry) {
+            let diff = Math.abs(context.startTime - resources[entry].startTime);
+            if (diff < likelyResource.diff) {
+                likelyResource = { index: entry, diff };
+            }
+        }
+        return resources[likelyResource.index];
+    }
+    return undefined;
+}
+// Copied from requestId generation on core
+function generateRequestId() {
+    function guid() {
+        function s4() {
+            return Math.floor((1 + Math.random()) * 0x10000)
+                .toString(16)
+                .substring(1);
+        }
+        return s4() + s4();
+    }
+    return [Math.round(performance.now() * 1000000), guid(), Math.round(Math.random() * 100000000)]
+        .join('')
+        .substring(0, 18);
+}
+
+function buildLuvioThirdPartyTrackerRegisterInterceptor() {
+    return (resourceRequest, context) => {
+        if (context && context.instrumentationId) {
+            instrumentationTracker.registerHandler(context.instrumentationId, 'luvio-inflight-network-request', () => {
+                // return false until we signal we are finished
+                return false;
+            });
+        }
+        return resolvedPromiseLike$2(resourceRequest);
+    };
+}
+
+function buildLuvioThirdPartyTrackerFinishInterceptor() {
+    return async (context) => {
+        if (context && context.instrumentationId) {
+            instrumentationTracker.markFinished(context.instrumentationId);
+        }
+    };
+}
+
+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);
+            context.startTime = performance.now();
+            createStartMark(requestId);
+        }
+        return resolvedPromiseLike$2(fetchArgs);
+    };
+}
+function buildLuvioTransportMarksSendInterceptor() {
+    return (resourceRequest, context) => {
+        if (context && context.instrumentationId) {
+            const requestId = context.instrumentationId;
+            setLuvioRequestIdHeader(resourceRequest, requestId);
+            context.startTime = performance.now();
+            context.url = location.origin + resourceRequest.baseUri + resourceRequest.basePath;
+            createStartMark(requestId);
+        }
+        return resolvedPromiseLike$2(resourceRequest);
+    };
+}
+function setLuvioRequestIdHeader(resourceRequest, requestId) {
+    // Ensure headers object exists
+    if (!resourceRequest.headers) {
+        resourceRequest.headers = {};
+    }
+    // Don't overwrite request id header if it already exists
+    if (!resourceRequest.headers[SFDC_REQUEST_ID_KEY]) {
+        resourceRequest.headers[SFDC_REQUEST_ID_KEY] = requestId;
+    }
+}
+
+const observer = new PerformanceObserver(() => { });
+observer.observe({ type: 'resource', buffered: true });
+function buildTransportMarksReceiveInterceptor() {
+    return async (response, context) => {
+        response
+            .clone()
+            .text()
+            .then(() => {
+            createEndMark(response.status, response.statusText, response.url, context, `OneStore resource timing failed to match for: ${response.url}`);
+        })
+            .catch((e) => {
+            logMessage(`OneStore transport marks received failed with: ${e}`);
+        });
+        return response;
+    };
+}
+function buildLuvioTransportMarksReceiveInterceptor() {
+    return async (response, context) => {
+        if (context && context.url) {
+            Promise.resolve(response)
+                .then(() => {
+                createEndMark(response.status, response.statusText, context.url, context, `Luvio resource timing failed to match for: ${context.url}`);
+            })
+                .catch((e) => {
+                logMessage(`Luvio transport marks received failed with: ${e}`);
+            });
+        }
+        return response;
+    };
+}
+
 function isOneRuntime() {
     return !!globalThis.LWR;
 }
@@ -6156,12 +6558,20 @@ const composedFetchNetworkAdapter = {
         }
         return ENABLED_PATH_MATCHERS.some((matcher) => matcher.test(path));
     },
-    adapter: setupLexNetworkAdapter(requestTracker, requestLogger, {
-        request: [buildLuvioPageScopedCacheRequestInterceptor(), buildLuvioCsrfTokenInterceptor()],
+    adapter: setupLexNetworkAdapter(requestLogger, {
+        createContext: createInstrumentationIdContext(),
+        request: [
+            buildLuvioThirdPartyTrackerRegisterInterceptor(),
+            buildLuvioTransportMarksSendInterceptor(),
+            buildLuvioPageScopedCacheRequestInterceptor(),
+            buildLuvioCsrfTokenInterceptor(),
+        ],
         response: [
             buildLexRuntimeLuvio5xxStatusResponseInterceptor(),
             buildLexRuntimeLuvioAuthExpirationRedirectResponseInterceptor(),
+            buildLuvioTransportMarksReceiveInterceptor(),
         ],
+        finally: [buildLuvioThirdPartyTrackerFinishInterceptor()],
     }),
 };
 
@@ -6185,22 +6595,6 @@ function buildThirdPartyTrackerRegisterInterceptor() {
     };
 }
 
-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
-    };
-}
-
 const DEFAULT_CONFIG$1 = {
     maxRetries: 1, // Only retry once after token refresh
 };
@@ -6291,8 +6685,8 @@ async function isCsrfError(response) {
         // Clone to avoid consuming the original response
         const cloned = response.clone();
         const body = await cloned.json();
-        // Check the error array format: data[0].errorCode
-        const errorCode = body?.data?.[0]?.errorCode;
+        // Check the error array format: body[0].errorCode
+        const errorCode = body?.[0]?.errorCode;
         return errorCode === 'INVALID_ACCESS_TOKEN';
     }
     catch {
@@ -6333,7 +6727,7 @@ const SFAP_BASE_URL = 'api.salesforce.com';
 const sfapJwtRepository = new JwtRepository();
 const sfapJwtManager = new JwtManager(sfapJwtRepository, platformSfapJwtResolver);
 function buildJwtAuthorizedSfapFetchServiceDescriptor(logger) {
-    const jwtAuthorizedFetchService = buildServiceDescriptor$1({
+    const jwtAuthorizedFetchService = buildServiceDescriptor$2({
         createContext: createInstrumentationIdContext(),
         request: [buildThirdPartyTrackerRegisterInterceptor(), buildJwtRequestInterceptor(logger)],
         retry: buildCsrfRetryInterceptor(),
@@ -6355,7 +6749,7 @@ function buildCopilotFetchServiceDescriptor(logger) {
         // we switch to JWT authentication this will need to change to incorporate the
         // Interceptor here with the logic in buildJwtAuthorizedSfapFetchServiceDescriptor()
         // above.
-        ...buildServiceDescriptor$1({
+        ...buildServiceDescriptor$2({
             createContext: createInstrumentationIdContext(),
             request: [
                 buildThirdPartyTrackerRegisterInterceptor(),
@@ -6405,7 +6799,7 @@ function buildCopilotFetchServiceDescriptor(logger) {
     };
 }
 function buildUnauthorizedFetchServiceDescriptor() {
-    const fetchService = buildServiceDescriptor$1({
+    const fetchService = buildServiceDescriptor$2({
         createContext: createInstrumentationIdContext(),
         request: [buildThirdPartyTrackerRegisterInterceptor()],
         retry: buildCsrfRetryInterceptor(),
@@ -9248,29 +9642,8 @@ function buildPageScopedCacheRequestInterceptor() {
     };
 }
 
-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 });
-        }
-    };
-}
-
 function buildLexRuntimeDefaultFetchServiceDescriptor(logger, retryService) {
-    const fetchService = buildServiceDescriptor$1({
+    const fetchService = buildServiceDescriptor$2({
         createContext: createInstrumentationIdContext(),
         request: [
             buildThirdPartyTrackerRegisterInterceptor(),
@@ -9282,18 +9655,16 @@ function buildLexRuntimeDefaultFetchServiceDescriptor(logger, retryService) {
         response: [
             buildLexRuntime5xxStatusResponseInterceptor(logger),
             buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger),
-        ],
-        finally: [
             buildTransportMarksReceiveInterceptor(),
-            buildThirdPartyTrackerFinishInterceptor(),
         ],
+        finally: [buildThirdPartyTrackerFinishInterceptor()],
     }, retryService);
     return {
         ...fetchService,
     };
 }
 function buildLexRuntimeAllow5xxFetchServiceDescriptor(logger, retryService) {
-    const fetchService = buildServiceDescriptor$1({
+    const fetchService = buildServiceDescriptor$2({
         createContext: createInstrumentationIdContext(),
         request: [
             buildThirdPartyTrackerRegisterInterceptor(),
@@ -9302,11 +9673,11 @@ function buildLexRuntimeAllow5xxFetchServiceDescriptor(logger, retryService) {
             buildCsrfTokenInterceptor(),
         ],
         retry: buildCsrfRetryInterceptor(),
-        response: [buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger)],
-        finally: [
+        response: [
+            buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger),
             buildTransportMarksReceiveInterceptor(),
-            buildThirdPartyTrackerFinishInterceptor(),
         ],
+        finally: [buildThirdPartyTrackerFinishInterceptor()],
     }, retryService);
     return {
         ...fetchService,
@@ -9716,15 +10087,6 @@ function setupQueryEvaluators(luvio, store) {
     luvio.registerTypeQueryEvaluator(UiApiNamespace, RecordRepresentationRepresentationType, recordRepresentationQueryEvaluator);
 }
 let __lexPrefetcher;
-const HARDCODED_REQUEST_LIMIT = 9;
-function getInflightRequestLimit() {
-    try {
-        return window['$A'].clientService.maxAllowedParallelXHRCounts();
-    }
-    catch (e) {
-        return HARDCODED_REQUEST_LIMIT;
-    }
-}
 const requestStrategyManager = new RequestStrategyManager();
 /**
  * Registers a request strategy to be utilized by PDL.
@@ -9783,9 +10145,7 @@ function setupPredictivePrefetcher(luvio) {
             }
         },
     });
-    const inflightRequestLimit = applyPredictionRequestLimit.isOpen({ fallback: false })
-        ? getInflightRequestLimit()
-        : 1000;
+    const inflightRequestLimit = configService.config.maxAllowedParallelXHRCounts;
     const prefetcherOptions = {
         inflightRequestLimit,
     };
@@ -9895,7 +10255,6 @@ function buildPredictorForContext(context) {
         },
     };
 }
-// LDS initialization logic, invoked directly by Aura component tests
 function initializeLDS() {
     const storeOptions = {
         scheduler: () => { },
@@ -9990,12 +10349,13 @@ function initializeOneStore(luvio) {
         buildServiceDescriptor$6(),
         buildServiceDescriptor$5(),
         buildServiceDescriptor$4(),
-        buildServiceDescriptor$3(),
+        buildServiceDescriptor$3$1(),
         buildServiceDescriptor$2$1(),
         buildServiceDescriptor$1$2(),
         buildServiceDescriptor$7(),
         buildLWCWireBindingsServiceDescriptor(),
         buildLWCGraphQLWireBindingsServiceDescriptor(),
+        configServiceDescriptor,
     ];
     setServices(services);
 }
@@ -10014,5 +10374,5 @@ function ldsEngineCreator() {
     return { name: 'ldsEngineCreator' };
 }
 
-export { LexRequestStrategy, PdlPrefetcherEventType, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, notifyUpdateAvailableFactory, registerRequestStrategy, saveRequestAsPrediction, subscribeToPrefetcherEvents, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.412.1-054d9a1111
+export { LexRequestStrategy, PdlPrefetcherEventType, PdlRequestPriority, buildPredictorForContext, configService, ldsEngineCreator as default, initializeLDS, initializeOneStore, notifyUpdateAvailableFactory, registerRequestStrategy, saveRequestAsPrediction, subscribeToPrefetcherEvents, unregisterRequestStrategy, whenPredictionsReady };
+// version: 1.414.1-a1d9b7b404

package/dist/types/__mocks__/@salesforce/lds-environment-settings.d.ts

@@ -0,0 +1,2 @@
+export declare function getEnvironmentSetting(): boolean;
+export declare const EnvironmentSettings: {};

package/dist/types/aura-instrumentation/main.d.ts

@@ -153,6 +153,7 @@ export declare function incrementRequestResponseCount(cb: () => FetchResponse<un
  */
 export declare function mark(name: string, content?: any): void;
 export declare function logObjectInfoChanged(): void;
+export declare function logMessage(message: string): void;
 /**
  * Create a new instrumentation cache stats and return it.
  *

package/dist/types/config-service-util.d.ts

@@ -0,0 +1,6 @@
+export type LDSConfig = {
+    maxAllowedParallelXHRCounts: number;
+    forceRecordTransactionsDisabled: boolean;
+};
+export declare const configServiceDescriptor: import("node_modules/@conduit-client/service-config/dist/types/v1/config").ConfigServiceDescriptor<LDSConfig, "default" | "lex" | "overrides">;
+export declare const configService: import("@conduit-client/service-config/v1").ConfigService<LDSConfig, "default" | "lex" | "overrides">;

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

@@ -0,0 +1 @@
+export declare function buildLuvioThirdPartyTrackerFinishInterceptor(): (context?: any) => Promise<void>;

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

@@ -2,3 +2,11 @@ export declare function createInstrumentationIdContext(): () => {
     instrumentationId: string;
 };
 export declare function createStartMark(requestId: string): void;
+export declare function createEndMark(responseStatus: number, responseStatusText: string, url: string, context?: any, errorMessage?: string): void;
+export type RequestTracker = {
+    hasTracker: () => boolean;
+    registerHandler: (request: any, name: string, loadedCheck: () => boolean) => void;
+    markFinished: (request: any) => void;
+};
+export declare let internalRequestTracker: RequestTracker;
+export declare function generateRequestId(): string;

package/dist/types/main.d.ts

@@ -5,6 +5,7 @@ import type { LexRequestStrategy } from './predictive-loading/request-strategy/l
 import { type LexRequest } from './predictive-loading/lex';
 export { PdlRequestPriority, PdlPrefetcherEventType } from './predictive-loading';
 export { LexRequestStrategy } from './predictive-loading/request-strategy/lex-request-strategy';
+export { configService } from './config-service-util';
 /**
  * Registers a request strategy to be utilized by PDL.
  * @param requestStrategy - {@link LexRequestStrategy} The request strategy/strategies to register.

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

@@ -1,5 +1,6 @@
 import { type ResourceRequest } from '@luvio/engine';
-import type { RequestLogger, RequestTracker } from '@salesforce/lds-network-fetch';
+import type { RequestLogger } from '@salesforce/lds-network-fetch';
+import { RequestTracker } from './instrumentation-utils';
 /**
  * Base set of url paths that this adapter can serve via HTTP when enabled.
  * Extend this list to support additional endpoints (see predicate wiring below).

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

@@ -0,0 +1,2 @@
+import { ResourceRequest } from '@luvio/engine';
+export declare function buildLuvioThirdPartyTrackerRegisterInterceptor(): (resourceRequest: ResourceRequest, context?: any) => PromiseLike<ResourceRequest>;

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

@@ -0,0 +1,4 @@
+import { ResponseInterceptor } from '@conduit-client/service-fetch-network/v1';
+import { ResponseInterceptor as LuvioResponseInterceptor } from '@salesforce/lds-network-fetch';
+export declare function buildTransportMarksReceiveInterceptor(): ResponseInterceptor;
+export declare function buildLuvioTransportMarksReceiveInterceptor(): LuvioResponseInterceptor;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.412.1",
+    "version": "1.414.1",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -34,57 +34,58 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-aura"
     },
     "devDependencies": {
-        "@conduit-client/service-provisioner": "3.7.1",
-        "@conduit-client/tools-core": "3.7.1",
-        "@salesforce/lds-adapters-apex": "^1.412.1",
-        "@salesforce/lds-adapters-uiapi": "^1.412.1",
-        "@salesforce/lds-ads-bridge": "^1.412.1",
-        "@salesforce/lds-aura-storage": "^1.412.1",
-        "@salesforce/lds-bindings": "^1.412.1",
-        "@salesforce/lds-instrumentation": "^1.412.1",
-        "@salesforce/lds-network-aura": "^1.412.1",
-        "@salesforce/lds-network-fetch": "^1.412.1",
+        "@conduit-client/service-provisioner": "3.9.0",
+        "@conduit-client/tools-core": "3.9.0",
+        "@salesforce/lds-adapters-apex": "^1.414.1",
+        "@salesforce/lds-adapters-uiapi": "^1.414.1",
+        "@salesforce/lds-ads-bridge": "^1.414.1",
+        "@salesforce/lds-aura-storage": "^1.414.1",
+        "@salesforce/lds-bindings": "^1.414.1",
+        "@salesforce/lds-instrumentation": "^1.414.1",
+        "@salesforce/lds-network-aura": "^1.414.1",
+        "@salesforce/lds-network-fetch": "^1.414.1",
         "jwt-encode": "1.0.1"
     },
     "dependencies": {
-        "@conduit-client/command-aura-graphql-normalized-cache-control": "3.7.1",
-        "@conduit-client/command-aura-network": "3.7.1",
-        "@conduit-client/command-aura-normalized-cache-control": "3.7.1",
-        "@conduit-client/command-aura-resource-cache-control": "3.7.1",
-        "@conduit-client/command-fetch-network": "3.7.1",
-        "@conduit-client/command-http-graphql-normalized-cache-control": "3.7.1",
-        "@conduit-client/command-http-normalized-cache-control": "3.7.1",
-        "@conduit-client/command-ndjson": "3.7.1",
-        "@conduit-client/command-network": "3.7.1",
-        "@conduit-client/command-sse": "3.7.1",
-        "@conduit-client/command-streaming": "3.7.1",
-        "@conduit-client/service-aura-network": "3.7.1",
-        "@conduit-client/service-bindings-imperative": "3.7.1",
-        "@conduit-client/service-bindings-lwc": "3.7.1",
-        "@conduit-client/service-cache": "3.7.1",
-        "@conduit-client/service-cache-control": "3.7.1",
-        "@conduit-client/service-cache-inclusion-policy": "3.7.1",
-        "@conduit-client/service-feature-flags": "3.7.1",
-        "@conduit-client/service-fetch-network": "3.7.1",
-        "@conduit-client/service-instrument-command": "3.7.1",
-        "@conduit-client/service-pubsub": "3.7.1",
-        "@conduit-client/service-store": "3.7.1",
-        "@conduit-client/utils": "3.7.1",
+        "@conduit-client/command-aura-graphql-normalized-cache-control": "3.9.0",
+        "@conduit-client/command-aura-network": "3.9.0",
+        "@conduit-client/command-aura-normalized-cache-control": "3.9.0",
+        "@conduit-client/command-aura-resource-cache-control": "3.9.0",
+        "@conduit-client/command-fetch-network": "3.9.0",
+        "@conduit-client/command-http-graphql-normalized-cache-control": "3.9.0",
+        "@conduit-client/command-http-normalized-cache-control": "3.9.0",
+        "@conduit-client/command-ndjson": "3.9.0",
+        "@conduit-client/command-network": "3.9.0",
+        "@conduit-client/command-sse": "3.9.0",
+        "@conduit-client/command-streaming": "3.9.0",
+        "@conduit-client/service-aura-network": "3.9.0",
+        "@conduit-client/service-bindings-imperative": "3.9.0",
+        "@conduit-client/service-bindings-lwc": "3.9.0",
+        "@conduit-client/service-cache": "3.9.0",
+        "@conduit-client/service-cache-control": "3.9.0",
+        "@conduit-client/service-cache-inclusion-policy": "3.9.0",
+        "@conduit-client/service-config": "3.9.0",
+        "@conduit-client/service-feature-flags": "3.9.0",
+        "@conduit-client/service-fetch-network": "3.9.0",
+        "@conduit-client/service-instrument-command": "3.9.0",
+        "@conduit-client/service-pubsub": "3.9.0",
+        "@conduit-client/service-store": "3.9.0",
+        "@conduit-client/utils": "3.9.0",
         "@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.412.1",
-        "@salesforce/lds-adapters-uiapi-lex": "^1.412.1",
-        "@salesforce/lds-luvio-service": "^1.412.1",
-        "@salesforce/lds-luvio-uiapi-records-service": "^1.412.1"
+        "@salesforce/lds-adapters-onestore-graphql": "^1.414.1",
+        "@salesforce/lds-adapters-uiapi-lex": "^1.414.1",
+        "@salesforce/lds-luvio-service": "^1.414.1",
+        "@salesforce/lds-luvio-uiapi-records-service": "^1.414.1"
     },
     "luvioBundlesize": [
         {
             "path": "./dist/ldsEngineCreator.js",
             "maxSize": {
-                "none": "350 kB",
+                "none": "365 kB",
                 "min": "190 kB",
-                "compressed": "57.2 kB"
+                "compressed": "59.2 kB"
             }
         }
     ],

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

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