@salesforce/lds-worker-api 1.428.0-dev14 → 1.428.0-dev16

package/dist/standalone/es/lds-worker-api.js

@@ -3283,7 +3283,7 @@ function resolveCachePolicy(cachePolicy, defaultCachePolicy) {
         }
     }
 }
-function isFetchResponse(error) {
+function isFetchResponse$1(error) {
     return error !== null && typeof error === 'object' && 'status' in error;
 }
 /**
@@ -3362,7 +3362,7 @@ class Environment {
                 // the new network adapter behavior
                 return reject(
                 // legacy network adapter check
-                isFetchResponse(error)
+                isFetchResponse$1(error)
                     ? {
                         ...error,
                         errorType: 'fetchResponse',
@@ -4274,7 +4274,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.428.0-dev14-d04322589b
+// version: 1.428.0-dev16-22ad12fb68
 
 // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
 function instrumentAdapter$1(createFunction, _metadata) {
@@ -5318,7 +5318,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     const { apiFamily, name } = metadata;
     return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
-// version: 1.428.0-dev14-d04322589b
+// version: 1.428.0-dev16-22ad12fb68
 
 function isSupportedEntity(_objectApiName) {
     return true;
@@ -32610,9 +32610,9 @@ withDefaultLuvio((luvio) => {
     throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
     throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
 });
-// version: 1.428.0-dev14-450676496d
+// version: 1.428.0-dev16-07fd0f90d6
 
-var allowUpdatesForNonCachedRecords = {
+var draftQueueMaxRetryAttemptsGate = {
     isOpen: function (e) {
         return e.fallback;
     },
@@ -32664,6 +32664,15 @@ const getInstrumentation = () => {
     return mockInstrumentation;
 };
 
+var allowUpdatesForNonCachedRecords = {
+    isOpen: function (e) {
+        return e.fallback;
+    },
+    hasError: function () {
+        return !0;
+    },
+};
+
 var caseSensitiveUserId = '005B0000000GR4OIAW';
 
 /**
@@ -47834,6 +47843,13 @@ function customActionHandler(executor, id, draftQueue) {
 }
 
 const DRAFT_SEGMENT = 'DRAFT';
+/**
+ * Metadata key under which an action's upload retry-attempt count is persisted.
+ * Lives in the action's durable `metadata` bag so the count survives app restarts
+ * (the in-memory backoff interval resets on every startQueue()). Written by the
+ * action handler on each retry and cleared when an action is manually retried.
+ */
+const DRAFT_ACTION_RETRY_COUNT_METADATA_KEY = 'retryCount';
 class DurableDraftQueue {
     getHandler(id) {
         const handler = this.handlers[id];
@@ -48192,10 +48208,14 @@ class DurableDraftQueue {
         if (!isDraftError(target)) {
             throw Error(`Action ${actionId} is not in Error state`);
         }
+        // A manual retry is a fresh start: clear the persisted upload retry-attempt
+        // count so the action doesn't immediately re-cap after a single failure.
+        const { [DRAFT_ACTION_RETRY_COUNT_METADATA_KEY]: _retryCount, ...metadataWithoutRetryCount } = target.metadata || {};
         let pendingAction = {
             ...target,
             status: DraftActionStatus.Pending,
             error: undefined,
+            metadata: metadataWithoutRetryCount,
         };
         await this.draftStore.writeAction(pendingAction);
         await this.notifyChangedListeners({
@@ -79603,6 +79623,322 @@ function makeEnvironmentUiApiRecordDraftAware(luvio, options, env) {
     return create$3(adapterSpecificEnvironments, {});
 }
 
+/**
+ * This function takes an unknown error and normalizes it to an Error object
+ */
+function normalizeError$1(error) {
+    if (typeof error === 'object' && error instanceof Error) {
+        return error;
+    }
+    else if (typeof error === 'string') {
+        return new Error(error);
+    }
+    return new Error(stringify$5(error));
+}
+/**
+ * Maximum number of times an action's upload will be retried before the action is
+ * transitioned to Error and surfaced to the consumer. Caps the otherwise-unbounded
+ * retry loop that can wedge the single-worker draft queue when an upload fails
+ * deterministically on every dispatch. Only enforced when the
+ * `lmr.draft-queue-max-retry-attempts` gate is open.
+ */
+const MAX_RETRY_ATTEMPTS = 5;
+const MAX_RETRY_ERROR_CODE = 'MAX_RETRY_ATTEMPTS_EXCEEDED';
+function isFetchResponse(failure) {
+    // The union is exactly FetchResponse | Error, so "not an Error" is the FetchResponse.
+    // This is safer than duck-typing on status/ok: a custom Error subclass that happens to
+    // carry those properties would be misclassified by a structural check.
+    return !(failure instanceof Error);
+}
+/**
+ * Builds the FetchResponse-shaped error attached to an action that has exhausted its
+ * upload retries. Shaped like a real network error response (status/statusText/ok/
+ * headers/body) so downstream consumers (DraftManager, queue instrumentation) that
+ * read `action.error.status`/`.body`/etc. behave consistently with a server error.
+ *
+ * The failure that caused the final attempt — a non-ok response (HTTP path) or a thrown
+ * error (catch path) — is folded into the body so the surfaced error says WHAT failed,
+ * not merely that the attempt cap was reached.
+ */
+function buildMaxRetryError(lastFailure) {
+    const capMessage = `Draft action exceeded ${MAX_RETRY_ATTEMPTS} upload retry attempts`;
+    if (isFetchResponse(lastFailure)) {
+        // Preserve the server's own error detail (status + body) so the surfaced error
+        // carries the last response that caused us to give up retrying.
+        return {
+            status: HttpStatusCode$2.ServerError,
+            statusText: capMessage,
+            ok: false,
+            headers: {},
+            body: {
+                errorCode: MAX_RETRY_ERROR_CODE,
+                message: `${capMessage}. Last response: status=${lastFailure.status} ${lastFailure.statusText}`,
+                lastResponseStatus: lastFailure.status,
+                lastResponseBody: lastFailure.body,
+            },
+        };
+    }
+    return {
+        status: HttpStatusCode$2.ServerError,
+        statusText: capMessage,
+        ok: false,
+        headers: {},
+        body: {
+            errorCode: MAX_RETRY_ERROR_CODE,
+            message: `${capMessage}. Last error: ${lastFailure.name}: ${lastFailure.message}`,
+            lastErrorName: lastFailure.name,
+            lastErrorMessage: lastFailure.message,
+        },
+    };
+}
+
+function attachObserversToAdapterRequestContext(observers, adapterRequestContext) {
+    if (adapterRequestContext === undefined) {
+        return { eventObservers: observers };
+    }
+    if (adapterRequestContext.eventObservers === undefined) {
+        return { ...adapterRequestContext, eventObservers: observers };
+    }
+    return {
+        ...adapterRequestContext,
+        eventObservers: adapterRequestContext.eventObservers.concat(observers),
+    };
+}
+/**
+ * Use this method to sanitize the unknown error object when
+ * we are unsure of the type of the error thrown
+ *
+ * @param err Unknown object to sanitize
+ * @returns an instance of error
+ */
+function normalizeError$2(err) {
+    if (err instanceof Error) {
+        return err;
+    }
+    else if (typeof err === 'string') {
+        return new Error(err);
+    }
+    return new Error(stringify$5(err));
+}
+// metrics
+/** GraphQL */
+const GRAPHQL_EVAL_ERROR = 'gql-eval-error';
+const GRAPHQL_EVAL_DB_READ_DURATION = 'gql-eval-db-read-duration';
+const GRAPHQL_EVAL_ROOT_QUERY_COUNT = 'gql-eval-root-query-count';
+const GRAPHQL_EVAL_TOTAL_QUERY_COUNT = 'gql-eval-total-query-count';
+const GRAPHQL_EVAL_MAX_CHILD_RELATIONSHIPS_COUNT = 'gql-eval-max-child-count';
+const GRAPHQL_EVAL_QUERY_RECORD_COUNT = 'gql-eval-query-record-count';
+const GRAPHQL_SNAPSHOT_REFRESH_UNDEFINED = 'gql-snapshot-refresh-undefined';
+/** Draft Queue */
+const DRAFT_QUEUE_STATE_STARTED = 'draft-queue-state-started';
+const DRAFT_QUEUE_STATE_ERROR = 'draft-queue-state-error';
+const DRAFT_QUEUE_STATE_WAITING = 'draft-queue-state-waiting';
+const DRAFT_QUEUE_STATE_STOPPED = 'draft-queue-state-stopped';
+const DRAFT_QUEUE_ACTION_ADDED = 'draft-queue-action-added';
+const DRAFT_QUEUE_ACTION_UPLOADING = 'draft-queue-action-uploading';
+const DRAFT_QUEUE_ACTION_COMPLETED = 'draft-queue-action-completed';
+const DRAFT_QUEUE_ACTION_DELETED = 'draft-queue-action-deleted';
+const DRAFT_QUEUE_ACTION_UPDATED = 'draft-queue-action-updated';
+const DRAFT_QUEUE_ACTION_FAILED = 'draft-queue-action-failed';
+const DRAFT_QUEUE_ACTION_UPLOAD_ERROR = 'draft-queue-action-upload-error';
+const DRAFT_QUEUE_TOTAL_MERGE_ACTIONS_CALLS = 'draft-queue-total-mergeActions-calls';
+/** Content Document */
+const CREATE_CONTENT_DOCUMENT_AND_VERSION_TOTAL_SYNTHESIZE_CALLS = 'content-document-version-total-synthesize-calls';
+const CREATE_CONTENT_DOCUMENT_AND_VERSION_DRAFT_SYNTHESIZE_ERROR = 'create-content-document-version-draft-synthesize-error';
+/** Priming */
+const PRIMING_TOTAL_SESSION_COUNT = 'priming-total-session-count';
+const PRIMING_TOTAL_ERROR_COUNT = 'priming-total-error-count';
+const PRIMING_TOTAL_PRIMED_COUNT = 'priming-total-primed-count';
+const PRIMING_TOTAL_CONFLICT_COUNT = 'priming-total-conflict-count';
+// logs
+const GRAPHQL_QUERY_PARSE_ERROR = 'gql-query-parse-error';
+const GRAPHQL_SQL_EVAL_PRECONDITION_ERROR = 'gql-sql-pre-eval-error';
+const GRAPHQL_CREATE_SNAPSHOT_ERROR = 'gql-create-snapshot-error';
+const DRAFT_AWARE_CREATE_CONTENT_DOCUMENT_AND_VERSION_ERROR = 'draft-aware-create-content-document-and-version-error';
+/** Garbage Collection */
+const GARBAGE_COLLECTION_AGGRESSIVE_TRIM_COUNT = 'garbage-collection-aggressive-trim-count';
+const GARBAGE_COLLECTION_AGGRESSIVE_TRIM_RECORDS_TRIMMED = 'garbage-collection-aggressive-trim-records-trimmed';
+const GARBAGE_COLLECTION_AGGRESSIVE_TRIM_TOTAL_RECORDS_BEFORE_TRIM = 'garbage-collection-aggressive-trim-total-records-before-trim';
+const ldsMobileInstrumentation$2 = getInstrumentation();
+const nimbusLogger = typeof __nimbus !== 'undefined' &&
+    __nimbus.plugins !== undefined &&
+    __nimbus.plugins.JSLoggerPlugin !== undefined
+    ? __nimbus.plugins.JSLoggerPlugin
+    : undefined;
+function reportGraphqlQueryParseError(err) {
+    const error = normalizeError$2(err);
+    const errorCode = GRAPHQL_QUERY_PARSE_ERROR;
+    // Metric
+    reportGraphqlAdapterError(errorCode);
+    // Log
+    ldsMobileInstrumentation$2.error(error, errorCode);
+}
+function reportGraphqlSqlEvalPreconditionError(err) {
+    const error = normalizeError$2(err);
+    const errorCode = GRAPHQL_SQL_EVAL_PRECONDITION_ERROR;
+    // Metric
+    reportGraphqlAdapterError(errorCode);
+    // Log
+    ldsMobileInstrumentation$2.error(error, errorCode);
+}
+function reportGraphqlCreateSnapshotError(err) {
+    const error = normalizeError$2(err);
+    const errorCode = GRAPHQL_CREATE_SNAPSHOT_ERROR;
+    // Metric
+    reportGraphqlAdapterError(errorCode);
+    // Log
+    ldsMobileInstrumentation$2.error(error, errorCode);
+}
+function reportGraphQlEvalDbReadDuration(duration) {
+    ldsMobileInstrumentation$2.trackValue(GRAPHQL_EVAL_DB_READ_DURATION, duration);
+}
+function reportGraphqlAdapterError(errorCode) {
+    // Increment overall count with errorCode as tag
+    ldsMobileInstrumentation$2.incrementCounter(GRAPHQL_EVAL_ERROR, 1, true, { errorCode });
+}
+function reportGraphqlQueryInstrumentation(data) {
+    const queryBuckets = [1, 2, 3, 4, 5, 10, 20, 50, 100];
+    const recordBuckets = [
+        1, 5, 10, 20, 50, 100, 1000, 2000, 5000, 10000, 50000, 100000, 1000000,
+    ];
+    ldsMobileInstrumentation$2.bucketValue(GRAPHQL_EVAL_ROOT_QUERY_COUNT, data.rootQueryCount, queryBuckets);
+    ldsMobileInstrumentation$2.bucketValue(GRAPHQL_EVAL_TOTAL_QUERY_COUNT, data.totalQueryCount, queryBuckets);
+    ldsMobileInstrumentation$2.bucketValue(GRAPHQL_EVAL_MAX_CHILD_RELATIONSHIPS_COUNT, data.maxChildRelationships, queryBuckets);
+    ldsMobileInstrumentation$2.bucketValue(GRAPHQL_EVAL_QUERY_RECORD_COUNT, data.requestedRecordCount, recordBuckets);
+}
+function incrementGraphQLRefreshUndfined() {
+    ldsMobileInstrumentation$2.incrementCounter(GRAPHQL_SNAPSHOT_REFRESH_UNDEFINED);
+}
+function reportDraftActionEvent(state, draftCount, message) {
+    if (nimbusLogger) {
+        nimbusLogger.logInfo(`Draft action event: ${state}, depth: ${draftCount}${message ? `, message: ${message}` : ''}`);
+    }
+    switch (state) {
+        case 'added':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_ADDED);
+            break;
+        case 'uploading':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_UPLOADING);
+            break;
+        case 'completed':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_COMPLETED);
+            break;
+        case 'deleted':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_DELETED);
+            break;
+        case 'failed':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_FAILED, 1, true);
+            break;
+        case 'updated':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_UPDATED);
+            break;
+    }
+}
+/**
+ * Reports an exception thrown while uploading a draft action. The thrown error is
+ * otherwise swallowed by the upload handler's retry path, leaving the failure
+ * invisible in telemetry; this surfaces it to o11y (log + counter) so a deterministic
+ * upload failure can be diagnosed instead of silently retried forever.
+ *
+ * PII: the device log line carries only the handler id, retry attempt, and the error
+ * NAME (e.g. "TypeError") — never the free-text error message, which can embed record
+ * ids (URL path segments) or server field-validation strings. The full normalized error
+ * (message + stack) is handed only to `ldsMobileInstrumentation.error`, the structured
+ * o11y error pipeline responsible for scrubbing/handling that detail. Also does NOT log
+ * the action's targetId/tag or any request body/field values.
+ */
+function reportDraftActionUploadError(error, handlerId, attempt) {
+    const normalized = normalizeError$2(error);
+    if (nimbusLogger) {
+        nimbusLogger.logError(`Draft action upload error: handler=${handlerId}, attempt=${attempt}, name=${normalized.name}`);
+    }
+    ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_UPLOAD_ERROR, 1, true, {
+        handlerId,
+    });
+    ldsMobileInstrumentation$2.error(normalized, DRAFT_QUEUE_ACTION_UPLOAD_ERROR);
+}
+function reportDraftQueueState(state, draftCount) {
+    if (nimbusLogger) {
+        nimbusLogger.logInfo(`Draft state changed: ${state}, depth: ${draftCount}`);
+    }
+    switch (state) {
+        case 'started':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_STATE_STARTED);
+            break;
+        case 'error':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_STATE_ERROR, 1, true);
+            break;
+        case 'waiting':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_STATE_WAITING);
+            break;
+        case 'stopped':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_STATE_STOPPED);
+            break;
+    }
+}
+function reportDraftAwareContentDocumentVersionSynthesizeError(err) {
+    let error;
+    if (err.body !== undefined) {
+        error = err.body;
+    }
+    else {
+        error = normalizeError$2(err);
+    }
+    const errorCode = DRAFT_AWARE_CREATE_CONTENT_DOCUMENT_AND_VERSION_ERROR;
+    const errorType = error.errorType;
+    const tags = {
+        errorCode,
+    };
+    if (errorType !== undefined) {
+        tags.errorType = errorType;
+    }
+    // Metric
+    ldsMobileInstrumentation$2.incrementCounter(CREATE_CONTENT_DOCUMENT_AND_VERSION_DRAFT_SYNTHESIZE_ERROR, 1, true, tags);
+    // Log
+    ldsMobileInstrumentation$2.error(error, errorCode);
+}
+function reportDraftAwareContentVersionSynthesizeCalls(mimeType) {
+    ldsMobileInstrumentation$2.incrementCounter(CREATE_CONTENT_DOCUMENT_AND_VERSION_TOTAL_SYNTHESIZE_CALLS, 1, undefined, { mimeType });
+}
+/** Priming */
+function reportPrimingSessionCreated() {
+    ldsMobileInstrumentation$2.incrementCounter(PRIMING_TOTAL_SESSION_COUNT, 1, undefined, {});
+}
+function reportPrimingError(errorType, recordCount) {
+    ldsMobileInstrumentation$2.incrementCounter(PRIMING_TOTAL_ERROR_COUNT, recordCount, undefined, {
+        errorType,
+    });
+}
+function reportPrimingSuccess(recordCount) {
+    ldsMobileInstrumentation$2.incrementCounter(PRIMING_TOTAL_PRIMED_COUNT, recordCount, undefined);
+}
+function reportPrimingConflict(resolutionType, recordCount) {
+    ldsMobileInstrumentation$2.incrementCounter(PRIMING_TOTAL_CONFLICT_COUNT, recordCount, undefined, {
+        resolutionType,
+    });
+}
+/** Network */
+function reportChunkCandidateUrlLength(urlLength) {
+    const buckets = [8000, 10000, 12000, 14000, 16000];
+    ldsMobileInstrumentation$2.bucketValue('chunk-candidate-url-length-histogram', urlLength, buckets);
+}
+/** Garbage Collection */
+function reportAggressiveTrimTriggered(trimCount, beforeTrimRecordCount, totalRecordsTrimmed) {
+    ldsMobileInstrumentation$2.trackValue(GARBAGE_COLLECTION_AGGRESSIVE_TRIM_COUNT, trimCount);
+    ldsMobileInstrumentation$2.trackValue(GARBAGE_COLLECTION_AGGRESSIVE_TRIM_TOTAL_RECORDS_BEFORE_TRIM, beforeTrimRecordCount);
+    ldsMobileInstrumentation$2.trackValue(GARBAGE_COLLECTION_AGGRESSIVE_TRIM_RECORDS_TRIMMED, totalRecordsTrimmed);
+}
+/** One Store Cache Purge */
+const ONESTORE_CACHE_PURGING_RECORDS_PURGED = 'onestore-cache-purging-records-purged';
+const ONESTORE_CACHE_PURGING_RECORDS_ERROR = 'onestore-cache-purging-records-error';
+function reportOneStoreRecordsPurgedFromCache(recordsPurged) {
+    ldsMobileInstrumentation$2.trackValue(ONESTORE_CACHE_PURGING_RECORDS_PURGED, recordsPurged);
+}
+function reportOneStoreCachePurgingError(error) {
+    const errorMessage = normalizeError$2(error);
+    ldsMobileInstrumentation$2.error(errorMessage, ONESTORE_CACHE_PURGING_RECORDS_ERROR);
+}
+
 const HTTP_HEADER_RETRY_AFTER = 'Retry-After';
 const HTTP_HEADER_IDEMPOTENCY_KEY = 'Idempotency-Key';
 const ERROR_CODE_IDEMPOTENCY_FEATURE_NOT_ENABLED = 'IDEMPOTENCY_FEATURE_NOT_ENABLED';
@@ -79753,20 +80089,89 @@ class AbstractResourceRequestActionHandler {
                 shouldRetry = true;
                 actionDataChanged = true;
             }
-            await actionErrored(shouldRetry
-                ? updatedAction
-                : {
+            if (shouldRetry) {
+                // Funnel the retry through the cap: when the gate is open this persists
+                // the attempt count and errors out once the cap is hit; when the gate is
+                // closed it behaves exactly as before. The non-ok response is the failure
+                // that would otherwise be retried.
+                await this.retryOrCap(updatedAction, response, actionErrored, retryDelayInMs, actionDataChanged);
+            }
+            else {
+                await actionErrored({
                     ...updatedAction,
                     error: response,
                     status: DraftActionStatus.Error,
-                }, shouldRetry, retryDelayInMs, actionDataChanged);
+                }, false, retryDelayInMs, actionDataChanged);
+            }
             return ProcessActionResult.ACTION_ERRORED;
         }
         catch (e) {
-            await actionErrored(action, true);
+            // #3 (ungated): the thrown exception is otherwise swallowed here, leaving a
+            // deterministic upload failure invisible in telemetry. Surface it to o11y
+            // before deciding whether to retry.
+            const error = normalizeError$1(e);
+            const attempt = this.getUploadRetryCount(action) + 1;
+            reportDraftActionUploadError(error, this.handlerId, attempt);
+            await this.retryOrCap(action, error, actionErrored);
             return ProcessActionResult.NETWORK_ERROR;
         }
     }
+    /**
+     * Reads the persisted upload retry-attempt count from the action's durable metadata
+     * bag. The count lives in metadata (rather than in-memory) so it survives app
+     * restarts and queue re-creation — the failure modes that let the unbounded retry
+     * loop run for days.
+     */
+    getUploadRetryCount(action) {
+        const parsed = Number(action.metadata?.[DRAFT_ACTION_RETRY_COUNT_METADATA_KEY]);
+        // Guard against a missing/corrupt persisted value: a NaN, fractional, or negative
+        // count must never weaken the cap. Floor to a non-negative integer, defaulting to 0.
+        if (!Number.isFinite(parsed) || parsed < 0) {
+            return 0;
+        }
+        return Math.floor(parsed);
+    }
+    /**
+     * Enforces the upload retry-attempt cap around the queue's `actionErrored` callback.
+     * Both retry paths — a retryable HTTP error and a thrown exception — funnel through
+     * here.
+     *
+     * The entire cap behavior is gated behind `lmr.draft-queue-max-retry-attempts`. When
+     * the gate is CLOSED this is a transparent passthrough: it issues the same
+     * `actionErrored(action, true, ...)` retry the queue made before this change, and
+     * writes no extra metadata. When the gate is OPEN it persists an incremented attempt
+     * count to the action's durable metadata and, once the action has failed
+     * {@link MAX_RETRY_ATTEMPTS} times, transitions it to Error (carrying a
+     * FetchResponse-shaped error that names the failure that exhausted the retries)
+     * instead of scheduling yet another retry.
+     */
+    async retryOrCap(action, lastFailure, actionErrored, retryDelayInMs, actionDataChanged) {
+        if (!draftQueueMaxRetryAttemptsGate.isOpen({ fallback: false })) {
+            // Gate closed: preserve the pre-existing unbounded-retry behavior exactly.
+            await actionErrored(action, true, retryDelayInMs, actionDataChanged);
+            return;
+        }
+        const attempt = this.getUploadRetryCount(action) + 1;
+        if (attempt >= MAX_RETRY_ATTEMPTS) {
+            await actionErrored({
+                ...action,
+                error: buildMaxRetryError(lastFailure),
+                status: DraftActionStatus.Error,
+            }, false);
+            return;
+        }
+        // Persist the incremented attempt count so it survives restarts. Forcing
+        // actionDataChanged ensures the queue writes the updated metadata before the
+        // action is rescheduled for retry.
+        const retryingAction = {
+            ...action,
+            metadata: {
+                ...action.metadata,
+                [DRAFT_ACTION_RETRY_COUNT_METADATA_KEY]: String(attempt),
+            },
+        };
+        await actionErrored(retryingAction, true, retryDelayInMs, true);
+    }
     async handleActionEnqueued(action) {
         const impactedKeys = await this.recordService.setSideEffectsForActions([action]);
         await this.recordService.reapplyRecordSideEffects(impactedKeys);
@@ -79930,6 +80335,13 @@ class AbstractResourceRequestActionHandler {
             this.isActionOfType(sourceAction)) {
             targetAction.status = DraftActionStatus.Pending;
             targetAction.data = sourceAction.data;
+            // Replacing an action's data re-queues it as a fresh upload, so the persisted
+            // upload retry-attempt count must not carry over — otherwise a previously-
+            // throttled action could immediately re-hit the cap on its first new attempt.
+            // (Mirrors the same clear in mergeActions.)
+            if (targetAction.metadata !== undefined) {
+                delete targetAction.metadata[DRAFT_ACTION_RETRY_COUNT_METADATA_KEY];
+            }
             return targetAction;
         }
         else {
@@ -79969,6 +80381,11 @@ class AbstractResourceRequestActionHandler {
         }
         // overlay metadata
         merged.metadata = { ...targetMetadata, ...sourceMetadata };
+        // A merge folds new user data into the action and re-queues it as a fresh upload,
+        // so the persisted upload retry-attempt count must not carry over — otherwise a
+        // previously-throttled action could immediately re-hit the cap on its first new
+        // attempt.
+        delete merged.metadata[DRAFT_ACTION_RETRY_COUNT_METADATA_KEY];
         // put status back to pending to auto upload if queue is active and targed is at the head.
         merged.status = DraftActionStatus.Pending;
         return merged;
@@ -80579,229 +80996,6 @@ class AbstractQuickActionHandler extends AbstractResourceRequestActionHandler {
     }
 }
 
-function attachObserversToAdapterRequestContext(observers, adapterRequestContext) {
-    if (adapterRequestContext === undefined) {
-        return { eventObservers: observers };
-    }
-    if (adapterRequestContext.eventObservers === undefined) {
-        return { ...adapterRequestContext, eventObservers: observers };
-    }
-    return {
-        ...adapterRequestContext,
-        eventObservers: adapterRequestContext.eventObservers.concat(observers),
-    };
-}
-/**
- * Use this method to sanitize the unknown error object when
- * we are unsure of the type of the error thrown
- *
- * @param err Unknown object to sanitize
- * @returns an instance of error
- */
-function normalizeError$1(err) {
-    if (err instanceof Error) {
-        return err;
-    }
-    else if (typeof err === 'string') {
-        return new Error(err);
-    }
-    return new Error(stringify$5(err));
-}
-// metrics
-/** GraphQL */
-const GRAPHQL_EVAL_ERROR = 'gql-eval-error';
-const GRAPHQL_EVAL_DB_READ_DURATION = 'gql-eval-db-read-duration';
-const GRAPHQL_EVAL_ROOT_QUERY_COUNT = 'gql-eval-root-query-count';
-const GRAPHQL_EVAL_TOTAL_QUERY_COUNT = 'gql-eval-total-query-count';
-const GRAPHQL_EVAL_MAX_CHILD_RELATIONSHIPS_COUNT = 'gql-eval-max-child-count';
-const GRAPHQL_EVAL_QUERY_RECORD_COUNT = 'gql-eval-query-record-count';
-const GRAPHQL_SNAPSHOT_REFRESH_UNDEFINED = 'gql-snapshot-refresh-undefined';
-/** Draft Queue */
-const DRAFT_QUEUE_STATE_STARTED = 'draft-queue-state-started';
-const DRAFT_QUEUE_STATE_ERROR = 'draft-queue-state-error';
-const DRAFT_QUEUE_STATE_WAITING = 'draft-queue-state-waiting';
-const DRAFT_QUEUE_STATE_STOPPED = 'draft-queue-state-stopped';
-const DRAFT_QUEUE_ACTION_ADDED = 'draft-queue-action-added';
-const DRAFT_QUEUE_ACTION_UPLOADING = 'draft-queue-action-uploading';
-const DRAFT_QUEUE_ACTION_COMPLETED = 'draft-queue-action-completed';
-const DRAFT_QUEUE_ACTION_DELETED = 'draft-queue-action-deleted';
-const DRAFT_QUEUE_ACTION_UPDATED = 'draft-queue-action-updated';
-const DRAFT_QUEUE_ACTION_FAILED = 'draft-queue-action-failed';
-const DRAFT_QUEUE_TOTAL_MERGE_ACTIONS_CALLS = 'draft-queue-total-mergeActions-calls';
-/** Content Document */
-const CREATE_CONTENT_DOCUMENT_AND_VERSION_TOTAL_SYNTHESIZE_CALLS = 'content-document-version-total-synthesize-calls';
-const CREATE_CONTENT_DOCUMENT_AND_VERSION_DRAFT_SYNTHESIZE_ERROR = 'create-content-document-version-draft-synthesize-error';
-/** Priming */
-const PRIMING_TOTAL_SESSION_COUNT = 'priming-total-session-count';
-const PRIMING_TOTAL_ERROR_COUNT = 'priming-total-error-count';
-const PRIMING_TOTAL_PRIMED_COUNT = 'priming-total-primed-count';
-const PRIMING_TOTAL_CONFLICT_COUNT = 'priming-total-conflict-count';
-// logs
-const GRAPHQL_QUERY_PARSE_ERROR = 'gql-query-parse-error';
-const GRAPHQL_SQL_EVAL_PRECONDITION_ERROR = 'gql-sql-pre-eval-error';
-const GRAPHQL_CREATE_SNAPSHOT_ERROR = 'gql-create-snapshot-error';
-const DRAFT_AWARE_CREATE_CONTENT_DOCUMENT_AND_VERSION_ERROR = 'draft-aware-create-content-document-and-version-error';
-/** Garbage Collection */
-const GARBAGE_COLLECTION_AGGRESSIVE_TRIM_COUNT = 'garbage-collection-aggressive-trim-count';
-const GARBAGE_COLLECTION_AGGRESSIVE_TRIM_RECORDS_TRIMMED = 'garbage-collection-aggressive-trim-records-trimmed';
-const GARBAGE_COLLECTION_AGGRESSIVE_TRIM_TOTAL_RECORDS_BEFORE_TRIM = 'garbage-collection-aggressive-trim-total-records-before-trim';
-const ldsMobileInstrumentation$2 = getInstrumentation();
-const nimbusLogger = typeof __nimbus !== 'undefined' &&
-    __nimbus.plugins !== undefined &&
-    __nimbus.plugins.JSLoggerPlugin !== undefined
-    ? __nimbus.plugins.JSLoggerPlugin
-    : undefined;
-function reportGraphqlQueryParseError(err) {
-    const error = normalizeError$1(err);
-    const errorCode = GRAPHQL_QUERY_PARSE_ERROR;
-    // Metric
-    reportGraphqlAdapterError(errorCode);
-    // Log
-    ldsMobileInstrumentation$2.error(error, errorCode);
-}
-function reportGraphqlSqlEvalPreconditionError(err) {
-    const error = normalizeError$1(err);
-    const errorCode = GRAPHQL_SQL_EVAL_PRECONDITION_ERROR;
-    // Metric
-    reportGraphqlAdapterError(errorCode);
-    // Log
-    ldsMobileInstrumentation$2.error(error, errorCode);
-}
-function reportGraphqlCreateSnapshotError(err) {
-    const error = normalizeError$1(err);
-    const errorCode = GRAPHQL_CREATE_SNAPSHOT_ERROR;
-    // Metric
-    reportGraphqlAdapterError(errorCode);
-    // Log
-    ldsMobileInstrumentation$2.error(error, errorCode);
-}
-function reportGraphQlEvalDbReadDuration(duration) {
-    ldsMobileInstrumentation$2.trackValue(GRAPHQL_EVAL_DB_READ_DURATION, duration);
-}
-function reportGraphqlAdapterError(errorCode) {
-    // Increment overall count with errorCode as tag
-    ldsMobileInstrumentation$2.incrementCounter(GRAPHQL_EVAL_ERROR, 1, true, { errorCode });
-}
-function reportGraphqlQueryInstrumentation(data) {
-    const queryBuckets = [1, 2, 3, 4, 5, 10, 20, 50, 100];
-    const recordBuckets = [
-        1, 5, 10, 20, 50, 100, 1000, 2000, 5000, 10000, 50000, 100000, 1000000,
-    ];
-    ldsMobileInstrumentation$2.bucketValue(GRAPHQL_EVAL_ROOT_QUERY_COUNT, data.rootQueryCount, queryBuckets);
-    ldsMobileInstrumentation$2.bucketValue(GRAPHQL_EVAL_TOTAL_QUERY_COUNT, data.totalQueryCount, queryBuckets);
-    ldsMobileInstrumentation$2.bucketValue(GRAPHQL_EVAL_MAX_CHILD_RELATIONSHIPS_COUNT, data.maxChildRelationships, queryBuckets);
-    ldsMobileInstrumentation$2.bucketValue(GRAPHQL_EVAL_QUERY_RECORD_COUNT, data.requestedRecordCount, recordBuckets);
-}
-function incrementGraphQLRefreshUndfined() {
-    ldsMobileInstrumentation$2.incrementCounter(GRAPHQL_SNAPSHOT_REFRESH_UNDEFINED);
-}
-function reportDraftActionEvent(state, draftCount, message) {
-    if (nimbusLogger) {
-        nimbusLogger.logInfo(`Draft action event: ${state}, depth: ${draftCount}${message ? `, message: ${message}` : ''}`);
-    }
-    switch (state) {
-        case 'added':
-            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_ADDED);
-            break;
-        case 'uploading':
-            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_UPLOADING);
-            break;
-        case 'completed':
-            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_COMPLETED);
-            break;
-        case 'deleted':
-            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_DELETED);
-            break;
-        case 'failed':
-            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_FAILED, 1, true);
-            break;
-        case 'updated':
-            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_UPDATED);
-            break;
-    }
-}
-function reportDraftQueueState(state, draftCount) {
-    if (nimbusLogger) {
-        nimbusLogger.logInfo(`Draft state changed: ${state}, depth: ${draftCount}`);
-    }
-    switch (state) {
-        case 'started':
-            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_STATE_STARTED);
-            break;
-        case 'error':
-            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_STATE_ERROR, 1, true);
-            break;
-        case 'waiting':
-            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_STATE_WAITING);
-            break;
-        case 'stopped':
-            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_STATE_STOPPED);
-            break;
-    }
-}
-function reportDraftAwareContentDocumentVersionSynthesizeError(err) {
-    let error;
-    if (err.body !== undefined) {
-        error = err.body;
-    }
-    else {
-        error = normalizeError$1(err);
-    }
-    const errorCode = DRAFT_AWARE_CREATE_CONTENT_DOCUMENT_AND_VERSION_ERROR;
-    const errorType = error.errorType;
-    const tags = {
-        errorCode,
-    };
-    if (errorType !== undefined) {
-        tags.errorType = errorType;
-    }
-    // Metric
-    ldsMobileInstrumentation$2.incrementCounter(CREATE_CONTENT_DOCUMENT_AND_VERSION_DRAFT_SYNTHESIZE_ERROR, 1, true, tags);
-    // Log
-    ldsMobileInstrumentation$2.error(error, errorCode);
-}
-function reportDraftAwareContentVersionSynthesizeCalls(mimeType) {
-    ldsMobileInstrumentation$2.incrementCounter(CREATE_CONTENT_DOCUMENT_AND_VERSION_TOTAL_SYNTHESIZE_CALLS, 1, undefined, { mimeType });
-}
-/** Priming */
-function reportPrimingSessionCreated() {
-    ldsMobileInstrumentation$2.incrementCounter(PRIMING_TOTAL_SESSION_COUNT, 1, undefined, {});
-}
-function reportPrimingError(errorType, recordCount) {
-    ldsMobileInstrumentation$2.incrementCounter(PRIMING_TOTAL_ERROR_COUNT, recordCount, undefined, {
-        errorType,
-    });
-}
-function reportPrimingSuccess(recordCount) {
-    ldsMobileInstrumentation$2.incrementCounter(PRIMING_TOTAL_PRIMED_COUNT, recordCount, undefined);
-}
-function reportPrimingConflict(resolutionType, recordCount) {
-    ldsMobileInstrumentation$2.incrementCounter(PRIMING_TOTAL_CONFLICT_COUNT, recordCount, undefined, {
-        resolutionType,
-    });
-}
-/** Network */
-function reportChunkCandidateUrlLength(urlLength) {
-    const buckets = [8000, 10000, 12000, 14000, 16000];
-    ldsMobileInstrumentation$2.bucketValue('chunk-candidate-url-length-histogram', urlLength, buckets);
-}
-/** Garbage Collection */
-function reportAggressiveTrimTriggered(trimCount, beforeTrimRecordCount, totalRecordsTrimmed) {
-    ldsMobileInstrumentation$2.trackValue(GARBAGE_COLLECTION_AGGRESSIVE_TRIM_COUNT, trimCount);
-    ldsMobileInstrumentation$2.trackValue(GARBAGE_COLLECTION_AGGRESSIVE_TRIM_TOTAL_RECORDS_BEFORE_TRIM, beforeTrimRecordCount);
-    ldsMobileInstrumentation$2.trackValue(GARBAGE_COLLECTION_AGGRESSIVE_TRIM_RECORDS_TRIMMED, totalRecordsTrimmed);
-}
-/** One Store Cache Purge */
-const ONESTORE_CACHE_PURGING_RECORDS_PURGED = 'onestore-cache-purging-records-purged';
-const ONESTORE_CACHE_PURGING_RECORDS_ERROR = 'onestore-cache-purging-records-error';
-function reportOneStoreRecordsPurgedFromCache(recordsPurged) {
-    ldsMobileInstrumentation$2.trackValue(ONESTORE_CACHE_PURGING_RECORDS_PURGED, recordsPurged);
-}
-function reportOneStoreCachePurgingError(error) {
-    const errorMessage = normalizeError$1(error);
-    ldsMobileInstrumentation$2.error(errorMessage, ONESTORE_CACHE_PURGING_RECORDS_ERROR);
-}
-
 const QUICK_ACTION_HANDLER = 'QUICK_ACTION_HANDLER';
 class QuickActionExecutionRepresentationHandler extends AbstractQuickActionHandler {
     constructor(getLuvio, draftRecordService, draftQueue, networkAdapter, isDraftId, sideEffectService, objectInfoService, getRecord) {
@@ -89423,7 +89617,7 @@ const withInstrumentation = (operation, config) => {
     return operation()
         .catch((err) => {
         hasError = true;
-        const error = normalizeError$1(err);
+        const error = normalizeError$2(err);
         tags['errorMessage'] = error.message;
         if (logError) {
             ldsMobileInstrumentation$2.error(error);
@@ -96242,7 +96436,7 @@ function buildServiceDescriptor$b(luvio) {
         },
     };
 }
-// version: 1.428.0-dev14-450676496d
+// version: 1.428.0-dev16-07fd0f90d6
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -96268,7 +96462,7 @@ function buildServiceDescriptor$a(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.428.0-dev14-450676496d
+// version: 1.428.0-dev16-07fd0f90d6
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -99002,7 +99196,7 @@ register$1({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$2,
 });
-// version: 1.428.0-dev14-d04322589b
+// version: 1.428.0-dev16-22ad12fb68
 
 const { create: create$2, keys: keys$2 } = Object;
 const { stringify, parse } = JSON;
@@ -106560,6 +106754,11 @@ function buildCommandClass(baseClass) {
                             Object.entries(this.latestUsedRecordIdToWeakEtagMap).forEach(([recordId, oneStoreRecordWeakEtag]) => {
                                 const normalizedLuvioRecord = this.services.luvioUiapiRecords.getNormalizedLuvioRecord(recordId, reader);
                                 if (!normalizedLuvioRecord) {
+                                    // A record that was present when this snapshot was read
+                                    // is now absent from the Luvio store (e.g. evicted by a
+                                    // uiRecordApi deleteRecord). Its disappearance changes the
+                                    // result set, so treat it as a change and re-emit.
+                                    dataChanged = true;
                                     return;
                                 }
                                 const luvioRecordWeakEtag = normalizedLuvioRecord.weakEtag;
@@ -107061,7 +107260,7 @@ function registerCallback(cb) {
         cb(graphql_v1_import, graphql_imperative$1, graphql_imperative_legacy_v1_import, graphql_state_manager, useOneStoreGraphQL);
     }
 }
-// version: 1.428.0-dev14-450676496d
+// version: 1.428.0-dev16-07fd0f90d6
 
 function createFragmentMap(documentNode) {
     const fragments = {};
@@ -136298,7 +136497,7 @@ register$1({
     configuration: { ...configurationForGraphQLAdapters$1 },
     instrument: instrument$1,
 });
-// version: 1.428.0-dev14-450676496d
+// version: 1.428.0-dev16-07fd0f90d6
 
 // On core the unstable adapters are re-exported with different names,
 // we want to match them here.
@@ -136450,7 +136649,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.428.0-dev14-450676496d
+// version: 1.428.0-dev16-07fd0f90d6
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -137249,7 +137448,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.428.0-dev14-d04322589b
+// version: 1.428.0-dev16-22ad12fb68
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -138565,4 +138764,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, evictExpiredCacheEntries, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, importLuvioAdapterModule, importOneStoreAdapterModule, invokeAdapter, invokeAdapterWithDraftToMerge, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, stopEviction, subscribeToAdapter };
-// version: 1.428.0-dev14-d04322589b
+// version: 1.428.0-dev16-22ad12fb68