@salesforce/lds-runtime-aura 1.462.0 → 1.464.0

package/dist/ldsEngineCreator.js

@@ -14,6 +14,7 @@
 /* proxy-compat-disable */
 import { HttpStatusCode as HttpStatusCode$2, InMemoryStore, Environment, Luvio, InMemoryStoreQueryEvaluator } from 'force/luvioEngine';
 import useOneStoreGraphql from '@salesforce/gate/lds.oneStoreGraphqlEnabled.ltng';
+import usePersistedQueries from '@salesforce/gate/lds.graphqlusepersistedqueries';
 import { instrument, buildRecordRepKeyFromId, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType, RecordRepresentationVersion } from 'force/ldsAdaptersUiapi';
 import { getInstrumentation } from 'o11y/client';
 import { findExecutableOperation, buildGraphQLInputExtension, addTypenameToDocument } from 'force/luvioGraphqlNormalization';
@@ -24,7 +25,7 @@ import { assertIsValid, JsonSchemaViolationError, MissingRequiredPropertyError }
 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, mark } from 'instrumentation/service';
-import { instrument as instrument$2, isCsrfMethod, getFetchMethod, isRetryableMethod, isRetryableReadPost, compilePathMatchers, setupLexNetworkAdapter, UIAPI_PUBLIC_PATHS, UIAPI_PRIVATE_PATHS, isRetryableOperationType } from 'force/ldsNetworkFetch';
+import { instrument as instrument$2, isMutatingMethod, getFetchMethod, isIdempotentWrite, readUiApiErrorCode, isRetryableMethod, isRetryableReadPost, parseRetryAfterMs, compilePathMatchers, setupLexNetworkAdapter, UIAPI_PUBLIC_PATHS, UIAPI_PRIVATE_PATHS, isRetryableOperationType } from 'force/ldsNetworkFetch';
 import { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR, instrument as instrument$3 } from 'force/ldsBindings';
 import { stateManagerInstrumentation, OperationTypeValue, 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 } from 'force/ldsInstrumentation';
 import { instrument as instrument$4 } from 'force/adsBridge';
@@ -383,6 +384,15 @@ function buildServiceDescriptor$q() {
   };
 }
 
+function applyOperationRequestOptions$1(init, operationType) {
+  if (operationType === void 0) {
+    return init;
+  }
+  return {
+    ...init,
+    onestore: { ...init?.onestore, retrySafe: operationType === "query" }
+  };
+}
 class AuraNetworkCommand extends NetworkCommand$1 {
   constructor(services) {
     super(services);
@@ -401,6 +411,18 @@ class AuraNetworkCommand extends NetworkCommand$1 {
       "Fetch parameters must be specified when using HTTP transport on an Aura adapter"
     );
   }
+  /**
+   * The command's operation type. Generated command subclasses override this
+   * getter with their concrete operation (see the generator's
+   * `generateOperationType`); the base returns `undefined` for commands that
+   * don't declare one. On the HTTP fallback path (`fetch`) it derives the
+   * request's `onestore.retrySafe` — reads (`query`) are retry-safe, writes
+   * (`mutation`) are not. Mirrors `FetchNetworkCommand.operationType`, which
+   * this class does not inherit (it extends `NetworkCommand` directly).
+   */
+  get operationType() {
+    return void 0;
+  }
   coerceAuraErrors(auraErrors) {
     return new UserVisibleError(getFetchResponseFromAuraError(auraErrors[0]));
   }
@@ -502,9 +524,11 @@ class AuraNetworkCommand extends NetworkCommand$1 {
         this.coerceAuraErrors
       );
     } else if (this.shouldUseFetch()) {
-      const params = this.fetchParams;
+      const [input, init] = this.fetchParams;
+      const initWithOptions = applyOperationRequestOptions$1(init, this.operationType);
       try {
-        return this.convertFetchResponseToData(this.services.fetch(...params));
+        const fetchCall = initWithOptions === void 0 ? this.services.fetch(input) : this.services.fetch(input, initWithOptions);
+        return this.convertFetchResponseToData(fetchCall);
       } catch (reason) {
         return resolvedPromiseLike$2(err$1(toError(reason)));
       }
@@ -1358,6 +1382,15 @@ class NetworkCommand extends BaseCommand {
   async afterRequestHooks(_options) {
   }
 }
+function applyOperationRequestOptions(init, operationType) {
+  if (operationType === void 0) {
+    return init;
+  }
+  return {
+    ...init,
+    onestore: { ...init?.onestore, retrySafe: operationType === "query" }
+  };
+}
 function isAbortableCommand(command) {
   return !!command && typeof command === "object" && "isAbortableCommand" in command && command.isAbortableCommand === true;
 }
@@ -1447,7 +1480,8 @@ const _FetchNetworkCommand = class _FetchNetworkCommand extends NetworkCommand {
    * `generateOperationType`); the base returns `undefined` for commands that
    * don't declare one (e.g. hand-written commands). Transport-layer
    * interceptors use it to tell a read (`query`) apart from a write — see
-   * `fetch`, which folds it into the context seed.
+   * `fetch`, which folds it into the context seed and derives
+   * `onestore.retrySafe` from it.
    */
   get operationType() {
     return void 0;
@@ -1456,8 +1490,9 @@ const _FetchNetworkCommand = class _FetchNetworkCommand extends NetworkCommand {
     try {
       const [input, init] = this.fetchParams;
       const operationType = this.operationType;
+      const initWithOptions = applyOperationRequestOptions(init, operationType);
       const seed = operationType === void 0 ? contextSeed : { operationType, ...contextSeed };
-      const initWithSeed = seed === void 0 ? init : { ...init, __contextSeed: seed };
+      const initWithSeed = seed === void 0 ? initWithOptions : { ...initWithOptions, __contextSeed: seed };
       const fetchCall = initWithSeed === void 0 ? this.services.fetch(input) : this.services.fetch(input, initWithSeed);
       return this.convertFetchResponseToData(fetchCall);
     } catch (reason) {
@@ -2596,7 +2631,7 @@ function buildServiceDescriptor$d(luvio) {
         },
     };
 }
-// version: 1.462.0-50d9a13ba4
+// version: 1.464.0-e54c238397
 
 class AuraGraphQLNormalizedCacheControlCommand extends AuraNormalizedCacheControlCommand {
   constructor(config, documentRootType, services) {
@@ -2935,7 +2970,7 @@ function buildServiceDescriptor$9(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.462.0-50d9a13ba4
+// version: 1.464.0-e54c238397
 
 class RetryService {
   constructor(defaultRetryPolicy) {
@@ -4491,7 +4526,12 @@ function buildServiceDescriptor$2(interceptors = {
       }
       const fetchArgs = cleanInit === void 0 ? [input] : [input, cleanInit];
       const baseContext = interceptors.createContext?.();
-      const context = contextSeed === void 0 ? baseContext : { ...baseContext, ...contextSeed };
+      const onestore = cleanInit?.onestore;
+      const context = contextSeed === void 0 && onestore === void 0 ? baseContext : {
+        ...baseContext,
+        ...contextSeed,
+        ...onestore !== void 0 && { onestore }
+      };
       const {
         request: requestInterceptors = [],
         retry: retryInterceptor = void 0,
@@ -4539,10 +4579,14 @@ function getTextEncoder() {
   }
   return textEncoder;
 }
-function buildCompressionInterceptor(config) {
-  const threshold = config.threshold ?? 1024;
+function buildCompressionInterceptor(defaultConfig) {
   return async (args) => {
     const [resource, options = {}] = args;
+    const config = options.onestore?.compression ?? defaultConfig;
+    if (config === void 0) {
+      return resolvedPromiseLike$2(args);
+    }
+    const threshold = config.threshold ?? 1024;
     if (!options.body || typeof options.body !== "string") {
       return resolvedPromiseLike$2(args);
     }
@@ -5941,7 +5985,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.462.0-2919385b97
+// version: 1.464.0-b35c0e7723
 
 const auraClientService = getAuraClientService();
 const defaultConfig = {
@@ -6315,7 +6359,13 @@ function getOrGenerateErrorId(responseBody, status, statusText) {
     return generateErrorId(context);
 }
 function buildLexRuntime5xxStatusResponseInterceptor(logger) {
-    return async (response) => {
+    return async (response, context) => {
+        // The caller opted in (`onestore.handleServerError`, exposed by the fetch service as
+        // `context.onestore`) to receive the 5xx itself, so skip the gack and the throw and
+        // let the response flow to the command's error handling.
+        if (context?.onestore?.handleServerError === true) {
+            return response;
+        }
         if (response.status >= 500 && response.status < 600) {
             const internalLogMessage = `LEX runtime 5xx: ${response.status} ${response.statusText || ''}`.trim();
             logger.warn(internalLogMessage);
@@ -6519,7 +6569,7 @@ function buildCsrfTokenInterceptor() {
             return resolvedPromiseLike$2(fetchArgs);
         }
         // Only add CSRF token for mutating operations
-        if (isCsrfMethod(getFetchMethod(fetchArgs))) {
+        if (isMutatingMethod(getFetchMethod(fetchArgs))) {
             const token = await getCsrfToken();
             if (token) {
                 // eslint-disable-next-line no-param-reassign
@@ -6547,7 +6597,7 @@ function buildLuvioCsrfTokenInterceptor() {
             resourceRequest.headers = {};
         }
         // Only add CSRF token for mutating operations
-        if (isCsrfMethod(resourceRequest.method)) {
+        if (isMutatingMethod(resourceRequest.method)) {
             // Don't overwrite existing CSRF token header if it already exists
             if (!resourceRequest.headers[CSRF_TOKEN_HEADER]) {
                 const token = await getCsrfToken();
@@ -6560,6 +6610,53 @@ function buildLuvioCsrfTokenInterceptor() {
     };
 }
 
+const IDEMPOTENCY_KEY_HEADER = 'Idempotency-Key';
+// Server-side idempotency error codes (UI SDK / UI-API `ApiExceptionCode`); the
+// mobile draft-queue handler is the reference consumer.
+const ERROR_CODE_IDEMPOTENCY_FEATURE_NOT_ENABLED = 'IDEMPOTENCY_FEATURE_NOT_ENABLED';
+const ERROR_CODE_IDEMPOTENCY_NOT_SUPPORTED = 'IDEMPOTENCY_NOT_SUPPORTED';
+const ERROR_CODE_IDEMPOTENCY_BACKEND_OPERATION_ERROR = 'IDEMPOTENCY_BACKEND_OPERATION_ERROR';
+const ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER = 'IDEMPOTENCY_KEY_USED_DIFFERENT_USER';
+const ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST = 'IDEMPOTENCY_CONCURRENT_REQUEST';
+const ERROR_CODE_IDEMPOTENCY_KEY_ALREADY_USED = 'IDEMPOTENCY_KEY_ALREADY_USED';
+/**
+ * Generates an RFC4122 v4 UUID for use as an idempotency key, preferring
+ * `crypto.randomUUID()` and falling back to a `Math.random()` builder if it is
+ * unavailable (matches the SFAP request-id approach in `network-sfap`).
+ */
+function mintIdempotencyKey() {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+/**
+ * Builds a Luvio request interceptor that mints and attaches an `Idempotency-Key`
+ * on mutations to onboarded endpoints, once per logical write, so the retry
+ * service re-sends the same key on every replay and the server can dedupe.
+ *
+ * Minting is gated here; retry *eligibility* is decided separately by
+ * `LuvioIdempotencyRetryPolicy` from the header's presence, so a stale
+ * registry flag can never cause an unsafe replay.
+ */
+function buildLuvioIdempotencyKeyInterceptor() {
+    return async (resourceRequest) => {
+        if (!resourceRequest.headers) {
+            resourceRequest.headers = {};
+        }
+        if (isMutatingMethod(resourceRequest.method) &&
+            isIdempotentWrite(resourceRequest.basePath) &&
+            !resourceRequest.headers[IDEMPOTENCY_KEY_HEADER]) {
+            resourceRequest.headers[IDEMPOTENCY_KEY_HEADER] = mintIdempotencyKey();
+        }
+        return resolvedPromiseLike$2(resourceRequest);
+    };
+}
+
 const ENTITY_ENCODING_HEADER = 'X-Chatter-Entity-Encoding';
 const ENTITY_ENCODING_DISABLED_VALUE = 'false';
 /**
@@ -6856,11 +6953,11 @@ function buildLuvioThirdPartyTrackerFinishInterceptor() {
     };
 }
 
-const DEFAULT_CONFIG$3 = {
+const DEFAULT_CONFIG$4 = {
     maxRetries: 1,
 };
 class LuvioCsrfTokenRetryPolicy extends RetryPolicy {
-    constructor(config = DEFAULT_CONFIG$3) {
+    constructor(config = DEFAULT_CONFIG$4) {
         super();
         this.config = config;
     }
@@ -6904,21 +7001,12 @@ class LuvioCsrfTokenRetryPolicy extends RetryPolicy {
         this.requestContext.request = { ...req, headers };
     }
 }
-/**
- * Returns true when a Luvio FetchResponse indicates a CSRF token error.
- * Body is already parsed JSON on FetchResponse, so no clone/json() needed.
- *
- * UIAPI error bodies come in both shapes: an object `{ errorCode, message }`
- * for single errors, or an array `[{ errorCode, message }]` for endpoints that
- * return collections of errors. Handle both.
- */
+/** True when a Luvio FetchResponse indicates a CSRF token error. */
 function isCsrfError$1(response) {
-    const body = response.body;
-    const errorCode = Array.isArray(body) ? body[0]?.errorCode : body?.errorCode;
-    return errorCode === 'INVALID_ACCESS_TOKEN';
+    return readUiApiErrorCode(response) === 'INVALID_ACCESS_TOKEN';
 }
 
-const DEFAULT_CONFIG$2 = {
+const DEFAULT_CONFIG$3 = {
     maxRetries: 3,
     maxTimeToRetry: 10000,
     baseDelay: 250,
@@ -6932,7 +7020,7 @@ class LuvioFetchThrottlingRetryPolicy extends RetryPolicy {
     // is why we take the plain `ResourceRequest` rather than the mutable-container
     // pattern the CSRF policy uses — that policy rewrites the request (new token)
     // between attempts; this one never mutates it.
-    constructor(config = DEFAULT_CONFIG$2, request) {
+    constructor(config = DEFAULT_CONFIG$3, request) {
         super();
         this.config = config;
         this.request = request;
@@ -6960,57 +7048,157 @@ class LuvioFetchThrottlingRetryPolicy extends RetryPolicy {
         return Math.max(0, delay + jitter);
     }
     parseRetryAfterHeader(result) {
-        const headers = result.headers;
-        if (!headers) {
-            return undefined;
-        }
-        // FetchResponse headers is a plain { [key: string]: string } object
-        // (no Headers.get available), so do a case-insensitive lookup manually.
-        let value;
-        for (const key in headers) {
-            if (key.toLowerCase() === 'retry-after') {
-                value = headers[key];
-                break;
+        return parseRetryAfterMs(result.headers);
+    }
+}
+
+const DEFAULT_CONFIG$2 = {
+    maxRetries: 3,
+};
+// The idempotency handler never emits 429 (that's throttling's domain). Its 503
+// is a keyed-write lock-acquire failure (scenario 7), not throttling's keyless
+// GET/read-POST 503 — the two never contend (see classifyResponse).
+const HTTP_STATUS_BAD_REQUEST = 400;
+const HTTP_STATUS_REQUEST_TIMEOUT = 408;
+const HTTP_STATUS_CONFLICT = 409;
+const HTTP_STATUS_UNPROCESSABLE_ENTITY = 422;
+const HTTP_STATUS_SERVER_ERROR = 500;
+const HTTP_STATUS_SERVICE_UNAVAILABLE = 503;
+// Terminal cases (IDEMPOTENCY_AUTHENTICATION_FAILED on 401, INVALID_IDEMPOTENCY_KEY
+// on 400) are deliberately absent so they fall through to 'none'.
+const STRIP_ERROR_CODES = [
+    ERROR_CODE_IDEMPOTENCY_FEATURE_NOT_ENABLED,
+    ERROR_CODE_IDEMPOTENCY_NOT_SUPPORTED,
+    ERROR_CODE_IDEMPOTENCY_BACKEND_OPERATION_ERROR,
+];
+const ROTATE_ERROR_CODES = [
+    ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER,
+    ERROR_CODE_IDEMPOTENCY_KEY_ALREADY_USED,
+];
+/**
+ * Maps an idempotent-write response to its disposition. Status alone is
+ * ambiguous (e.g. 409 is same-key for a concurrent request but rotate for a
+ * different user), so pair it with the body's errorCode.
+ */
+function classifyResponse(response) {
+    const errorCode = readUiApiErrorCode(response);
+    // FetchResponse.status is typed as HttpStatusCode, which omits 408/409/422
+    // even though the idempotency handler emits them; widen to match.
+    const status = response.status;
+    switch (status) {
+        case HTTP_STATUS_SERVER_ERROR:
+            return errorCode === ERROR_CODE_IDEMPOTENCY_BACKEND_OPERATION_ERROR ? 'strip' : 'none';
+        case HTTP_STATUS_BAD_REQUEST:
+            // FEATURE_NOT_ENABLED / NOT_SUPPORTED → strip. Any other 400 (incl.
+            // INVALID_IDEMPOTENCY_KEY and CSRF's INVALID_ACCESS_TOKEN) is terminal.
+            return errorCode !== undefined && STRIP_ERROR_CODES.includes(errorCode)
+                ? 'strip'
+                : 'none';
+        case HTTP_STATUS_REQUEST_TIMEOUT:
+            // Backend connection timeout — the write may have already committed;
+            // replay same-key so the server can dedupe.
+            return 'same-key';
+        case HTTP_STATUS_SERVICE_UNAVAILABLE:
+            // Lock-acquire failure (scenario 7): the write never committed. Only a
+            // keyed write reaches here (shouldRetry gates on key presence) — a
+            // keyless 503 is the throttling policy's GET/read-POST case.
+            return 'same-key';
+        case HTTP_STATUS_CONFLICT:
+            // KEY_USED_DIFFERENT_USER → rotate; CONCURRENT_REQUEST → same key.
+            if (errorCode !== undefined && ROTATE_ERROR_CODES.includes(errorCode)) {
+                return 'rotate';
             }
+            return errorCode === ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST ? 'same-key' : 'none';
+        case HTTP_STATUS_UNPROCESSABLE_ENTITY:
+            // Same key reused for a different request body → needs a new key.
+            return errorCode === ERROR_CODE_IDEMPOTENCY_KEY_ALREADY_USED ? 'rotate' : 'none';
+        default:
+            return 'none';
+    }
+}
+/**
+ * Retry policy for writes carrying an `Idempotency-Key`. A peer of the CSRF and
+ * throttling policies in the composed retry chain, not a modification of
+ * either: its 503 (keyed-write lock-acquire) and throttling's 503 (keyless
+ * GET/read-POST) never contend because they key off different requests, and it
+ * only claims a 400/409 when the body carries an idempotency-specific
+ * errorCode, so it never steals CSRF's INVALID_ACCESS_TOKEN.
+ *
+ * Eligibility follows from the header's *presence* on the request, not from
+ * the mint interceptor's registry flag — so a stale flag can never cause an
+ * unsafe replay.
+ */
+class LuvioIdempotencyRetryPolicy extends RetryPolicy {
+    constructor(config = DEFAULT_CONFIG$2) {
+        super();
+        this.config = config;
+    }
+    setRequestContext(context) {
+        this.requestContext = context;
+    }
+    async shouldRetry(result, context) {
+        if (context.attempt >= this.config.maxRetries) {
+            return false;
         }
-        if (!value) {
-            return undefined;
+        const headers = this.requestContext?.request.headers;
+        if (!headers || !headers[IDEMPOTENCY_KEY_HEADER]) {
+            return false;
         }
-        const trimmed = value.trim();
-        if (/^\d+$/.test(trimmed)) {
-            const seconds = Number(trimmed);
-            if (Number.isFinite(seconds) && seconds >= 0) {
-                return seconds * 1000;
-            }
-            return undefined;
+        return classifyResponse(result) !== 'none';
+    }
+    async calculateDelay(result, _context) {
+        // Only same-key replays (408/409/503) carry a Retry-After to honor;
+        // strip/rotate retry immediately.
+        if (classifyResponse(result) !== 'same-key') {
+            return 0;
         }
-        const IMF_FIXDATE = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4} \d{2}:\d{2}:\d{2} GMT$/;
-        if (!IMF_FIXDATE.test(trimmed)) {
-            return undefined;
+        // Honor the server's Retry-After in full, like the mobile handler — it's
+        // a lock-hold hint, not a client-owned backoff (unlike the throttling
+        // sibling's capped delay). maxRetries bounds replays instead.
+        return parseRetryAfterMs(result.headers) ?? 0;
+    }
+    async prepareRetry(result, _context) {
+        if (!this.requestContext) {
+            return;
         }
-        const millis = Date.parse(trimmed);
-        if (Number.isFinite(millis)) {
-            return Math.max(0, millis - Date.now());
+        const disposition = classifyResponse(result);
+        if (disposition === 'same-key' || disposition === 'none') {
+            return;
         }
-        return undefined;
+        const req = this.requestContext.request;
+        // Drop the existing key via immutable spread (matches the CSRF policy).
+        const { [IDEMPOTENCY_KEY_HEADER]: _stale, ...remainingHeaders } = req.headers ?? {};
+        const headers = disposition === 'rotate'
+            ? { ...remainingHeaders, [IDEMPOTENCY_KEY_HEADER]: mintIdempotencyKey() }
+            : // 'strip': retry plain — the feature is unavailable for this request.
+                remainingHeaders;
+        this.requestContext.request = { ...req, headers };
     }
 }
 
 /**
- * Builds the LuvioRetryInterceptor used by the UIAPI fetch adapter.
+ * Builds the LuvioRetryInterceptor used by the UIAPI fetch adapter. A fresh
+ * RetryService and policies are created per request to keep the
+ * mutableRequest context isolated across concurrent requests.
  *
- * A fresh RetryService and policy instances are created per request to keep the
- * CSRF policy's mutableRequest context isolated from concurrent requests.
+ * Policy order matters: ComposedRetryPolicy uses the first matching policy's
+ * shouldRetry/delay. A keyed-write 503 fails throttling's method gate, so it
+ * falls to the idempotency policy to replay same-key.
  */
 function buildLuvioFetchRetryInterceptor() {
     return (request, doFetch) => {
+        const idempotencyPolicy = new LuvioIdempotencyRetryPolicy();
         const csrfPolicy = new LuvioCsrfTokenRetryPolicy();
         const composedPolicy = new ComposedRetryPolicy([
+            idempotencyPolicy,
             new LuvioFetchThrottlingRetryPolicy(undefined, request),
             csrfPolicy,
         ]);
         const retryService = new RetryService(composedPolicy);
         const mutableRequest = { request };
+        // Both policies rewrite headers on the shared request between attempts
+        // (idempotency strips/rotates the key; CSRF refreshes the token).
+        idempotencyPolicy.setRequestContext(mutableRequest);
         csrfPolicy.setRequestContext(mutableRequest);
         return retryService.applyRetry(() => doFetch(mutableRequest.request));
     };
@@ -7244,6 +7432,7 @@ const composedFetchNetworkAdapter = {
             buildLuvioTransportMarksSendInterceptor(),
             buildLuvioPageScopedCacheRequestInterceptor(),
             buildLuvioCsrfTokenInterceptor(),
+            buildLuvioIdempotencyKeyInterceptor(),
             buildLuvioFirstPartyHeaderInterceptor(),
             buildLuvioEntityEncodingInterceptor(),
         ],
@@ -7507,15 +7696,21 @@ function buildFetchRetryInterceptor() {
 }
 
 /**
- * The context-seed key under which a custom command forwards its JWT mint
+ * Legacy context-seed key under which a custom command forwards its JWT mint
  * parameters. The framework's `buildServiceDescriptor` merges the request init's
  * `__contextSeed` onto the per-request interceptor context, so this interceptor
- * reads the params off `context[JWT_MINT_PARAMS_SEED_KEY]`.
+ * can read the params off `context[JWT_MINT_PARAMS_SEED_KEY]`.
+ *
+ * **Transitional.** The first-class channel is now the typed
+ * `init.onestore.mintParams` field (onestore 3.29.0), which this interceptor
+ * prefers. This seed key remains only as a fallback while the core
+ * `onestore-custom-adapters` producers still write `__contextSeed`; it — together
+ * with the `context` fallback and the interceptor's `context` parameter — is
+ * removed once those producers emit `onestore.mintParams`. That removal is the
+ * follow-up PR #8314 (tracked under W-24472492).
  *
- * This is a cross-team contract: the custom command writes this key, this
- * interceptor reads it. It is intentionally an opaque key — OneStore does not
- * define it and never inspects the param shape; the typed shape lives in the
- * resolver.
+ * It is intentionally an opaque key — OneStore does not define it and never
+ * inspects the param shape; the typed shape lives in the resolver.
  */
 const JWT_MINT_PARAMS_SEED_KEY = 'jwtMintParams';
 /**
@@ -7546,15 +7741,17 @@ function hasAuthorizationHeader([resource, options]) {
  * Builds the request interceptor that bridges the per-request context seed to the
  * dispatching SFAP JwtManager for the **parameterized** mint path.
  *
- * For a parameterized SFAP command, the context carries `jwtMintParams`. This
- * interceptor reads them, calls `jwtManager.getJwt(params)` (which the dispatching
- * resolver routes to the parameterized resolver), attaches the `Authorization`
- * header, and rewrites the request URL via the minted `baseUri`. The presence of
- * that `Authorization` header is the signal the descriptor's guarded legacy
- * interceptor uses to skip — so the legacy path does not mint a second time.
+ * For a parameterized SFAP command, the mint params arrive on the typed
+ * `init.onestore.mintParams` field (preferred) or, transitionally, under the
+ * legacy `context[jwtMintParams]` seed. This interceptor reads them (onestore
+ * first), calls `jwtManager.getJwt(params)` (which the dispatching resolver routes
+ * to the parameterized resolver), attaches the `Authorization` header, and
+ * rewrites the request URL via the minted `baseUri`. The presence of that
+ * `Authorization` header is the signal the descriptor's guarded legacy interceptor
+ * uses to skip — so the legacy path does not mint a second time.
  *
- * For a legacy parameterless command the context carries no `jwtMintParams`, so
- * this interceptor **early-returns on its first line** and the request flows
+ * For a legacy parameterless command neither channel carries mint params, so this
+ * interceptor **early-returns on its first statement** and the request flows
  * unchanged to the legacy `buildJwtRequestHeaderInterceptor` — guaranteeing zero
  * behavior change for non-opted-in adapters.
  *
@@ -7568,8 +7765,11 @@ function hasAuthorizationHeader([resource, options]) {
  */
 function buildJwtParameterizationInterceptor(jwtManager, jwtRequestModifier = (_extraInfo, fetchArgs) => fetchArgs) {
     return (fetchArgs, context) => {
-        const jwtContext = context;
-        const mintParams = jwtContext?.[JWT_MINT_PARAMS_SEED_KEY];
+        // Prefer the typed `init.onestore.mintParams`; fall back to the legacy
+        // `context[JWT_MINT_PARAMS_SEED_KEY]` seed while the core producers still
+        // write it (transitional dual-read — see JWT_MINT_PARAMS_SEED_KEY).
+        const mintParams = fetchArgs[1]?.onestore?.mintParams ??
+            context?.[JWT_MINT_PARAMS_SEED_KEY];
         // No mint params → not a parameterized request. Do nothing; the legacy
         // interceptor handles it. This MUST be the first statement so non-opted-in
         // SFAP commands observe no work at all.
@@ -7664,7 +7864,8 @@ function buildJwtAuthorizedSfapFetchServiceDescriptor(logger) {
  *
  * It reuses the module's `sfapJwtManager`: `cdp_url` is emitted on the same
  * `SFAP_API`-scope JWT, so the Data360 command mints the same kind of token — it
- * just forwards the data-cloud scopes via the context-seed `jwtMintParams`.
+ * just forwards the data-cloud scopes via `onestore.mintParams` (or, transitionally,
+ * the legacy context-seed `jwtMintParams`).
  *
  * Gated behind its own `data_360_cdp_url_rewrite` auth-scope tag so it binds ONLY to
  * the Data360 command — the SFAP fleet never flows past this interceptor.
@@ -7795,10 +7996,11 @@ function buildJwtRequestInterceptor(logger) {
  * (`cdp_url`), and modifiers only receive `extraInfo`. So — like the copilot
  * interceptor that reads `decodedInfo.iss` — it holds the token directly:
  *
- *   1. Read the command's `jwtMintParams` off the per-request context seed and
- *      mint (via the parameterized SFAP resolver, routed by the dispatching
- *      resolver inside `sfapJwtManager`). Without mint params there is no token
- *      to authorize with, so leave the request untouched.
+ *   1. Read the command's mint params from `init.onestore.mintParams` (preferred)
+ *      or the legacy per-request context seed, and mint (via the parameterized
+ *      SFAP resolver, routed by the dispatching resolver inside `sfapJwtManager`).
+ *      Without mint params there is no token to authorize with, so leave the
+ *      request untouched.
  *   2. Decode `cdp_url` from the JWT and resolve the tenant-specific endpoint
  *      (TSE). `cdp_url` is a bare host, so a scheme is prepended before parsing
  *      and the protocol is forced to `https:`.
@@ -7817,7 +8019,11 @@ function buildJwtRequestInterceptor(logger) {
  */
 function buildData360HostRewriteInterceptor(logger) {
     return (fetchArgs, context) => {
-        const mintParams = context?.[JWT_MINT_PARAMS_SEED_KEY];
+        // Prefer the typed `init.onestore.mintParams`; fall back to the legacy
+        // `context[JWT_MINT_PARAMS_SEED_KEY]` seed while the core producers still
+        // write it (transitional dual-read — see JWT_MINT_PARAMS_SEED_KEY).
+        const mintParams = fetchArgs[1]?.onestore?.mintParams ??
+            context?.[JWT_MINT_PARAMS_SEED_KEY];
         // No mint params → not a parameterized Data360 request. Nothing to do.
         if (mintParams === undefined) {
             return resolvedPromiseLike$2(fetchArgs);
@@ -8462,6 +8668,10 @@ function getLexRuntimeDefaultInterceptorConfig(logger) {
             buildCsrfTokenInterceptor(),
             buildEntityEncodingInterceptor(),
             buildFirstPartyHeaderInterceptor(),
+            // Per-request gzip: compresses only operations that opt in via
+            // `init.onestore.compression`; a pass-through no-op otherwise. Last in
+            // the chain so it compresses the final body, after body-modifying interceptors.
+            buildCompressionInterceptor(),
         ],
         retry: buildFetchRetryInterceptor(),
         response: [
@@ -9171,6 +9381,8 @@ function initializeOneStore(luvio) {
     // across LEX and sites. Paired with the HTTP UIAPI fetch path being
     // disabled on sites (see network-fetch.ts).
     featureFlagsService.set('graphQLUseAura', true);
+    // Persisted (named) GraphQL queries; no consumers yet (W-23971639).
+    featureFlagsService.set('graphQLUsePersistedQueries', usePersistedQueries.isOpen({ fallback: false }));
     const services = [
         instrumentationServiceDescriptor,
         buildLexRuntimeDefaultFetchServiceDescriptor(loggerService, retryService),
@@ -9237,4 +9449,4 @@ function ldsEngineCreator() {
 }
 
 export { PDL_ENGINE_REGISTRATION_ID, buildPredictorForContext, configService, ldsEngineCreator as default, initializeLDS, initializeOneStore, notifyUpdateAvailableFactory };
-// version: 1.462.0-50d9a13ba4
+// version: 1.464.0-e54c238397

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

@@ -20,7 +20,8 @@ export declare function buildJwtAuthorizedSfapFetchServiceDescriptor(logger: Log
  *
  * It reuses the module's `sfapJwtManager`: `cdp_url` is emitted on the same
  * `SFAP_API`-scope JWT, so the Data360 command mints the same kind of token — it
- * just forwards the data-cloud scopes via the context-seed `jwtMintParams`.
+ * just forwards the data-cloud scopes via `onestore.mintParams` (or, transitionally,
+ * the legacy context-seed `jwtMintParams`).
  *
  * Gated behind its own `data_360_cdp_url_rewrite` auth-scope tag so it binds ONLY to
  * the Data360 command — the SFAP fleet never flows past this interceptor.

package/dist/types/request-interceptors/idempotency-key.d.ts

@@ -0,0 +1,24 @@
+import type { ResourceRequest } from '@luvio/engine';
+export declare const IDEMPOTENCY_KEY_HEADER = "Idempotency-Key";
+export declare const ERROR_CODE_IDEMPOTENCY_FEATURE_NOT_ENABLED = "IDEMPOTENCY_FEATURE_NOT_ENABLED";
+export declare const ERROR_CODE_IDEMPOTENCY_NOT_SUPPORTED = "IDEMPOTENCY_NOT_SUPPORTED";
+export declare const ERROR_CODE_IDEMPOTENCY_BACKEND_OPERATION_ERROR = "IDEMPOTENCY_BACKEND_OPERATION_ERROR";
+export declare const ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER = "IDEMPOTENCY_KEY_USED_DIFFERENT_USER";
+export declare const ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST = "IDEMPOTENCY_CONCURRENT_REQUEST";
+export declare const ERROR_CODE_IDEMPOTENCY_KEY_ALREADY_USED = "IDEMPOTENCY_KEY_ALREADY_USED";
+/**
+ * Generates an RFC4122 v4 UUID for use as an idempotency key, preferring
+ * `crypto.randomUUID()` and falling back to a `Math.random()` builder if it is
+ * unavailable (matches the SFAP request-id approach in `network-sfap`).
+ */
+export declare function mintIdempotencyKey(): string;
+/**
+ * Builds a Luvio request interceptor that mints and attaches an `Idempotency-Key`
+ * on mutations to onboarded endpoints, once per logical write, so the retry
+ * service re-sends the same key on every replay and the server can dedupe.
+ *
+ * Minting is gated here; retry *eligibility* is decided separately by
+ * `LuvioIdempotencyRetryPolicy` from the header's presence, so a stale
+ * registry flag can never cause an unsafe replay.
+ */
+export declare function buildLuvioIdempotencyKeyInterceptor(): (resourceRequest: ResourceRequest) => Promise<ResourceRequest>;

package/dist/types/request-interceptors/jwt-parameterization.d.ts

@@ -3,15 +3,21 @@ import { type JwtRequestModifier } from '@conduit-client/service-fetch-network/v
 import type { JwtManager } from '@conduit-client/jwt-manager';
 import type { ExtraInfo } from '../network-sfap';
 /**
- * The context-seed key under which a custom command forwards its JWT mint
+ * Legacy context-seed key under which a custom command forwards its JWT mint
  * parameters. The framework's `buildServiceDescriptor` merges the request init's
  * `__contextSeed` onto the per-request interceptor context, so this interceptor
- * reads the params off `context[JWT_MINT_PARAMS_SEED_KEY]`.
+ * can read the params off `context[JWT_MINT_PARAMS_SEED_KEY]`.
  *
- * This is a cross-team contract: the custom command writes this key, this
- * interceptor reads it. It is intentionally an opaque key — OneStore does not
- * define it and never inspects the param shape; the typed shape lives in the
- * resolver.
+ * **Transitional.** The first-class channel is now the typed
+ * `init.onestore.mintParams` field (onestore 3.29.0), which this interceptor
+ * prefers. This seed key remains only as a fallback while the core
+ * `onestore-custom-adapters` producers still write `__contextSeed`; it — together
+ * with the `context` fallback and the interceptor's `context` parameter — is
+ * removed once those producers emit `onestore.mintParams`. That removal is the
+ * follow-up PR #8314 (tracked under W-24472492).
+ *
+ * It is intentionally an opaque key — OneStore does not define it and never
+ * inspects the param shape; the typed shape lives in the resolver.
  */
 export declare const JWT_MINT_PARAMS_SEED_KEY = "jwtMintParams";
 /**
@@ -27,15 +33,17 @@ export declare function hasAuthorizationHeader([resource, options]: FetchParamet
  * Builds the request interceptor that bridges the per-request context seed to the
  * dispatching SFAP JwtManager for the **parameterized** mint path.
  *
- * For a parameterized SFAP command, the context carries `jwtMintParams`. This
- * interceptor reads them, calls `jwtManager.getJwt(params)` (which the dispatching
- * resolver routes to the parameterized resolver), attaches the `Authorization`
- * header, and rewrites the request URL via the minted `baseUri`. The presence of
- * that `Authorization` header is the signal the descriptor's guarded legacy
- * interceptor uses to skip — so the legacy path does not mint a second time.
+ * For a parameterized SFAP command, the mint params arrive on the typed
+ * `init.onestore.mintParams` field (preferred) or, transitionally, under the
+ * legacy `context[jwtMintParams]` seed. This interceptor reads them (onestore
+ * first), calls `jwtManager.getJwt(params)` (which the dispatching resolver routes
+ * to the parameterized resolver), attaches the `Authorization` header, and
+ * rewrites the request URL via the minted `baseUri`. The presence of that
+ * `Authorization` header is the signal the descriptor's guarded legacy interceptor
+ * uses to skip — so the legacy path does not mint a second time.
  *
- * For a legacy parameterless command the context carries no `jwtMintParams`, so
- * this interceptor **early-returns on its first line** and the request flows
+ * For a legacy parameterless command neither channel carries mint params, so this
+ * interceptor **early-returns on its first statement** and the request flows
  * unchanged to the legacy `buildJwtRequestHeaderInterceptor` — guaranteeing zero
  * behavior change for non-opted-in adapters.
  *

package/dist/types/retry-interceptors/luvio-fetch-retry.d.ts

@@ -1,8 +1,11 @@
 import type { LuvioRetryInterceptor } from '@salesforce/lds-network-fetch';
 /**
- * Builds the LuvioRetryInterceptor used by the UIAPI fetch adapter.
+ * Builds the LuvioRetryInterceptor used by the UIAPI fetch adapter. A fresh
+ * RetryService and policies are created per request to keep the
+ * mutableRequest context isolated across concurrent requests.
  *
- * A fresh RetryService and policy instances are created per request to keep the
- * CSRF policy's mutableRequest context isolated from concurrent requests.
+ * Policy order matters: ComposedRetryPolicy uses the first matching policy's
+ * shouldRetry/delay. A keyed-write 503 fails throttling's method gate, so it
+ * falls to the idempotency policy to replay same-key.
  */
 export declare function buildLuvioFetchRetryInterceptor(): LuvioRetryInterceptor;

package/dist/types/retry-policies/luvio-csrf-token-retry-policy.d.ts

@@ -19,13 +19,6 @@ export declare class LuvioCsrfTokenRetryPolicy extends RetryPolicy<FetchResponse
     calculateDelay(_result: FetchResponse<any>, _context: RetryContext<FetchResponse<any>>): Promise<number>;
     prepareRetry(_result: FetchResponse<any>, _context: RetryContext<FetchResponse<any>>): Promise<void>;
 }
-/**
- * Returns true when a Luvio FetchResponse indicates a CSRF token error.
- * Body is already parsed JSON on FetchResponse, so no clone/json() needed.
- *
- * UIAPI error bodies come in both shapes: an object `{ errorCode, message }`
- * for single errors, or an array `[{ errorCode, message }]` for endpoints that
- * return collections of errors. Handle both.
- */
+/** True when a Luvio FetchResponse indicates a CSRF token error. */
 export declare function isCsrfError(response: FetchResponse<any>): boolean;
 export {};

package/dist/types/retry-policies/luvio-idempotency-retry-policy.d.ts

@@ -0,0 +1,29 @@
+import type { RetryContext } from '@conduit-client/service-retry/v1';
+import { RetryPolicy } from '@conduit-client/service-retry/v1';
+import type { FetchResponse } from '@luvio/engine';
+import type { MutableLuvioRequest } from './luvio-csrf-token-retry-policy';
+type LuvioIdempotencyRetryPolicyConfig = {
+    maxRetries: number;
+};
+/**
+ * Retry policy for writes carrying an `Idempotency-Key`. A peer of the CSRF and
+ * throttling policies in the composed retry chain, not a modification of
+ * either: its 503 (keyed-write lock-acquire) and throttling's 503 (keyless
+ * GET/read-POST) never contend because they key off different requests, and it
+ * only claims a 400/409 when the body carries an idempotency-specific
+ * errorCode, so it never steals CSRF's INVALID_ACCESS_TOKEN.
+ *
+ * Eligibility follows from the header's *presence* on the request, not from
+ * the mint interceptor's registry flag — so a stale flag can never cause an
+ * unsafe replay.
+ */
+export declare class LuvioIdempotencyRetryPolicy extends RetryPolicy<FetchResponse<any>> {
+    private config;
+    private requestContext?;
+    constructor(config?: LuvioIdempotencyRetryPolicyConfig);
+    setRequestContext(context: MutableLuvioRequest): void;
+    shouldRetry(result: FetchResponse<any>, context: RetryContext<FetchResponse<any>>): Promise<boolean>;
+    calculateDelay(result: FetchResponse<any>, _context: RetryContext<FetchResponse<any>>): Promise<number>;
+    prepareRetry(result: FetchResponse<any>, _context: RetryContext<FetchResponse<any>>): Promise<void>;
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.462.0",
+    "version": "1.464.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime.",
     "main": "dist/ldsEngineCreator.js",
@@ -34,53 +34,53 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-aura"
     },
     "devDependencies": {
-        "@conduit-client/service-provisioner": "3.29.0",
-        "@conduit-client/tools-core": "3.29.0",
-        "@salesforce/lds-adapters-apex": "^1.462.0",
-        "@salesforce/lds-adapters-uiapi": "^1.462.0",
-        "@salesforce/lds-ads-bridge": "^1.462.0",
-        "@salesforce/lds-aura-storage": "^1.462.0",
-        "@salesforce/lds-bindings": "^1.462.0",
-        "@salesforce/lds-instrumentation": "^1.462.0",
-        "@salesforce/lds-network-adapter": "^1.462.0",
-        "@salesforce/lds-network-aura": "^1.462.0",
-        "@salesforce/lds-network-fetch": "^1.462.0",
+        "@conduit-client/service-provisioner": "3.32.0",
+        "@conduit-client/tools-core": "3.32.0",
+        "@salesforce/lds-adapters-apex": "^1.464.0",
+        "@salesforce/lds-adapters-uiapi": "^1.464.0",
+        "@salesforce/lds-ads-bridge": "^1.464.0",
+        "@salesforce/lds-aura-storage": "^1.464.0",
+        "@salesforce/lds-bindings": "^1.464.0",
+        "@salesforce/lds-instrumentation": "^1.464.0",
+        "@salesforce/lds-network-adapter": "^1.464.0",
+        "@salesforce/lds-network-aura": "^1.464.0",
+        "@salesforce/lds-network-fetch": "^1.464.0",
         "jwt-encode": "1.0.1"
     },
     "dependencies": {
-        "@conduit-client/command-aura-graphql-normalized-cache-control": "3.29.0",
-        "@conduit-client/command-aura-network": "3.29.0",
-        "@conduit-client/command-aura-normalized-cache-control": "3.29.0",
-        "@conduit-client/command-fetch-network": "3.29.0",
-        "@conduit-client/command-http-graphql-normalized-cache-control": "3.29.0",
-        "@conduit-client/command-http-normalized-cache-control": "3.29.0",
-        "@conduit-client/command-ndjson": "3.29.0",
-        "@conduit-client/command-network": "3.29.0",
-        "@conduit-client/command-sse": "3.29.0",
-        "@conduit-client/command-streaming": "3.29.0",
-        "@conduit-client/jwt-manager": "3.29.0",
-        "@conduit-client/service-aura-network": "3.29.0",
-        "@conduit-client/service-bindings-imperative": "3.29.0",
-        "@conduit-client/service-bindings-lwc": "3.29.0",
-        "@conduit-client/service-cache": "3.29.0",
-        "@conduit-client/service-cache-control": "3.29.0",
-        "@conduit-client/service-cache-inclusion-policy": "3.29.0",
-        "@conduit-client/service-config": "3.29.0",
-        "@conduit-client/service-feature-flags": "3.29.0",
-        "@conduit-client/service-fetch-network": "3.29.0",
-        "@conduit-client/service-instrument-command": "3.29.0",
-        "@conduit-client/service-pubsub": "3.29.0",
-        "@conduit-client/service-renewable-resource-manager": "3.29.0",
-        "@conduit-client/service-store": "3.29.0",
-        "@conduit-client/utils": "3.29.0",
+        "@conduit-client/command-aura-graphql-normalized-cache-control": "3.32.0",
+        "@conduit-client/command-aura-network": "3.32.0",
+        "@conduit-client/command-aura-normalized-cache-control": "3.32.0",
+        "@conduit-client/command-fetch-network": "3.32.0",
+        "@conduit-client/command-http-graphql-normalized-cache-control": "3.32.0",
+        "@conduit-client/command-http-normalized-cache-control": "3.32.0",
+        "@conduit-client/command-ndjson": "3.32.0",
+        "@conduit-client/command-network": "3.32.0",
+        "@conduit-client/command-sse": "3.32.0",
+        "@conduit-client/command-streaming": "3.32.0",
+        "@conduit-client/jwt-manager": "3.32.0",
+        "@conduit-client/service-aura-network": "3.32.0",
+        "@conduit-client/service-bindings-imperative": "3.32.0",
+        "@conduit-client/service-bindings-lwc": "3.32.0",
+        "@conduit-client/service-cache": "3.32.0",
+        "@conduit-client/service-cache-control": "3.32.0",
+        "@conduit-client/service-cache-inclusion-policy": "3.32.0",
+        "@conduit-client/service-config": "3.32.0",
+        "@conduit-client/service-feature-flags": "3.32.0",
+        "@conduit-client/service-fetch-network": "3.32.0",
+        "@conduit-client/service-instrument-command": "3.32.0",
+        "@conduit-client/service-pubsub": "3.32.0",
+        "@conduit-client/service-renewable-resource-manager": "3.32.0",
+        "@conduit-client/service-store": "3.32.0",
+        "@conduit-client/utils": "3.32.0",
         "@luvio/network-adapter-composable": "0.161.2",
         "@luvio/network-adapter-fetch": "0.161.2",
         "@lwc/state": "^0.29.0",
-        "@salesforce/lds-adapters-onestore-graphql": "^1.462.0",
+        "@salesforce/lds-adapters-onestore-graphql": "^1.464.0",
         "@salesforce/lds-adapters-uiapi-lex": "^1.415.0",
-        "@salesforce/lds-durable-storage": "^1.462.0",
-        "@salesforce/lds-luvio-service": "^1.462.0",
-        "@salesforce/lds-luvio-uiapi-records-service": "^1.462.0"
+        "@salesforce/lds-durable-storage": "^1.464.0",
+        "@salesforce/lds-luvio-service": "^1.464.0",
+        "@salesforce/lds-luvio-uiapi-records-service": "^1.464.0"
     },
     "luvioBundlesize": [
         {