@salesforce/lds-runtime-mobile 1.443.0 → 1.445.0

package/dist/main.js

@@ -19,8 +19,9 @@ import { withRegistration, register } from '@salesforce/lds-default-luvio';
 import { setupInstrumentation, instrumentAdapter as instrumentAdapter$1, instrumentLuvio, setLdsAdaptersUiapiInstrumentation, setLdsNetworkAdapterInstrumentation } from '@salesforce/lds-instrumentation';
 import { HttpStatusCode as HttpStatusCode$1, setBypassDeepFreeze, StoreKeySet, StringKeyInMemoryStore, Reader, serializeStructuredKey, deepFreeze as deepFreeze$1, emitAdapterEvent, ingestShape, coerceConfig as coerceConfig$1, typeCheckConfig as typeCheckConfig$h, createResourceParams as createResourceParams$h, StoreKeyMap, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$f, resolveLink, createCustomAdapterEventEmitter, isFileReference, Environment, Luvio, InMemoryStore } from '@luvio/engine';
 import { isSupportedEntity, configuration, getObjectInfoAdapterFactory, RECORD_ID_PREFIX, RECORD_FIELDS_KEY_JUNCTION, isStoreKeyRecordViewEntity, extractRecordIdFromStoreKey, buildRecordRepKeyFromId, keyBuilderRecord, RecordRepresentationTTL, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, getRecordId18 as getRecordId18$1, getRecordsAdapterFactory as getRecordsAdapterFactory$1, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getObjectInfosAdapterFactory, getObjectInfoDirectoryAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationVersion } from '@salesforce/lds-adapters-uiapi';
-import allowUpdatesForNonCachedRecords from '@salesforce/gate/lmr.allowUpdatesForNonCachedRecords';
+import draftQueueMaxRetryAttemptsGate from '@salesforce/gate/lmr.draft-queue-max-retry-attempts';
 import { getInstrumentation, idleDetector } from 'o11y/client';
+import allowUpdatesForNonCachedRecords from '@salesforce/gate/lmr.allowUpdatesForNonCachedRecords';
 import caseSensitiveUserId from '@salesforce/user/Id';
 import { Kind as Kind$1, visit as visit$1, isObjectType, defaultFieldResolver, buildSchema, parse as parse$8, extendSchema, isScalarType, execute, print } from '@luvio/graphql-parser';
 import graphqlRelationshipFieldsPerf from '@salesforce/gate/lds.graphqlRelationshipFieldsPerf';
@@ -2297,7 +2298,7 @@ function customActionHandler(executor, id, draftQueue) {
             }, result.error.type === CustomActionErrorType.NETWORK_ERROR);
         }
     };
-    const buildPendingAction = (action, queue) => {
+    const buildPendingAction = (action, queue, observabilityContext) => {
         const { data, tag, targetId, handler } = action;
         const id = generateUniqueDraftActionId(queue.map((a) => a.id));
         return Promise.resolve({
@@ -2309,6 +2310,7 @@ function customActionHandler(executor, id, draftQueue) {
             timestamp: Date.now(),
             metadata: data,
             handler,
+            observabilityContext,
         });
     };
     const getQueueOperationsForCompletingDrafts = (_queue, action) => {
@@ -2344,6 +2346,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];
@@ -2480,12 +2489,12 @@ class DurableDraftQueue {
             return aTime - bTime;
         });
     }
-    async enqueue(handlerId, data) {
+    async enqueue(handlerId, data, observabilityContext) {
         return this.workerPool.push({
             workFn: async () => {
                 let queue = await this.getQueueActions();
                 const handler = this.getHandler(handlerId);
-                const pendingAction = (await handler.buildPendingAction(data, queue));
+                const pendingAction = (await handler.buildPendingAction(data, queue, observabilityContext));
                 await this.draftStore.writeAction(pendingAction);
                 queue = await this.getQueueActions();
                 await this.notifyChangedListeners({
@@ -2712,10 +2721,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({
@@ -3307,7 +3320,7 @@ class DraftManager {
     }
     buildDraftQueueItem(action) {
         const operationType = getOperationTypeFrom(action);
-        const { id, status, timestamp, targetId, metadata } = action;
+        const { id, status, timestamp, targetId, metadata, observabilityContext } = action;
         const item = {
             id,
             targetId,
@@ -3315,6 +3328,7 @@ class DraftManager {
             timestamp,
             operationType,
             metadata,
+            observabilityContext,
         };
         if (isDraftError(action)) {
             // We should always return an array, if the body is just a dictionary,
@@ -3473,7 +3487,7 @@ const snapshotRefreshOptions = {
  * @param data Data to be JSON-stringified.
  * @returns JSON.stringified value with consistent ordering of keys.
  */
-function stableJSONStringify$1(node) {
+function stableJSONStringify(node) {
     // This is for Date values.
     if (node && node.toJSON && typeof node.toJSON === 'function') {
         // eslint-disable-next-line no-param-reassign
@@ -3496,7 +3510,7 @@ function stableJSONStringify$1(node) {
             if (i) {
                 out += ',';
             }
-            out += stableJSONStringify$1(node[i]) || 'null';
+            out += stableJSONStringify(node[i]) || 'null';
         }
         return out + ']';
     }
@@ -3507,7 +3521,7 @@ function stableJSONStringify$1(node) {
     out = '';
     for (i = 0; i < keys.length; i++) {
         const key = keys[i];
-        const value = stableJSONStringify$1(node[key]);
+        const value = stableJSONStringify(node[key]);
         if (!value) {
             continue;
         }
@@ -40790,7 +40804,7 @@ function ingestTypeWithStrategy(astNode, state, isCursorConnectionType, { key, i
     }
     if (existingData !== undefined && existingData !== null && ObjectPrototypeHasOwnProperty$1.call(existingData, "__type") === false) {
         const mergedData = mergeData(existingData, newData);
-        if (!equalsObject(existingData, mergedData, (propA, propB) => stableJSONStringify$1(propA) === stableJSONStringify$1(propB))) { // naive impl
+        if (!equalsObject(existingData, mergedData, (propA, propB) => stableJSONStringify(propA) === stableJSONStringify(propB))) { // naive impl
             luvio.storePublish(key, mergedData);
         }
     }
@@ -42137,6 +42151,324 @@ 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$1.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$1.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(err) {
+    if (err instanceof Error) {
+        return err;
+    }
+    else if (typeof err === 'string') {
+        return new Error(err);
+    }
+    return new Error(stringify$5(err));
+}
+
+const O11Y_NAMESPACE_LDS_MOBILE = 'lds-mobile';
+// 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 = getInstrumentation(O11Y_NAMESPACE_LDS_MOBILE);
+const nimbusLogger = typeof __nimbus !== 'undefined' &&
+    __nimbus.plugins !== undefined &&
+    __nimbus.plugins.JSLoggerPlugin !== undefined
+    ? __nimbus.plugins.JSLoggerPlugin
+    : undefined;
+function reportGraphqlQueryParseError(err) {
+    const error = normalizeError(err);
+    const errorCode = GRAPHQL_QUERY_PARSE_ERROR;
+    // Metric
+    reportGraphqlAdapterError(errorCode);
+    // Log
+    ldsMobileInstrumentation.error(error, errorCode);
+}
+function reportGraphqlSqlEvalPreconditionError(err) {
+    const error = normalizeError(err);
+    const errorCode = GRAPHQL_SQL_EVAL_PRECONDITION_ERROR;
+    // Metric
+    reportGraphqlAdapterError(errorCode);
+    // Log
+    ldsMobileInstrumentation.error(error, errorCode);
+}
+function reportGraphqlCreateSnapshotError(err) {
+    const error = normalizeError(err);
+    const errorCode = GRAPHQL_CREATE_SNAPSHOT_ERROR;
+    // Metric
+    reportGraphqlAdapterError(errorCode);
+    // Log
+    ldsMobileInstrumentation.error(error, errorCode);
+}
+function reportGraphQlEvalDbReadDuration(duration) {
+    ldsMobileInstrumentation.trackValue(GRAPHQL_EVAL_DB_READ_DURATION, duration);
+}
+function reportGraphqlAdapterError(errorCode) {
+    // Increment overall count with errorCode as tag
+    ldsMobileInstrumentation.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.bucketValue(GRAPHQL_EVAL_ROOT_QUERY_COUNT, data.rootQueryCount, queryBuckets);
+    ldsMobileInstrumentation.bucketValue(GRAPHQL_EVAL_TOTAL_QUERY_COUNT, data.totalQueryCount, queryBuckets);
+    ldsMobileInstrumentation.bucketValue(GRAPHQL_EVAL_MAX_CHILD_RELATIONSHIPS_COUNT, data.maxChildRelationships, queryBuckets);
+    ldsMobileInstrumentation.bucketValue(GRAPHQL_EVAL_QUERY_RECORD_COUNT, data.requestedRecordCount, recordBuckets);
+}
+function incrementGraphQLRefreshUndfined() {
+    ldsMobileInstrumentation.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.incrementCounter(DRAFT_QUEUE_ACTION_ADDED);
+            break;
+        case 'uploading':
+            ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_ACTION_UPLOADING);
+            break;
+        case 'completed':
+            ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_ACTION_COMPLETED);
+            break;
+        case 'deleted':
+            ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_ACTION_DELETED);
+            break;
+        case 'failed':
+            ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_ACTION_FAILED, 1, true);
+            break;
+        case 'updated':
+            ldsMobileInstrumentation.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(error);
+    if (nimbusLogger) {
+        nimbusLogger.logError(`Draft action upload error: handler=${handlerId}, attempt=${attempt}, name=${normalized.name}`);
+    }
+    ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_ACTION_UPLOAD_ERROR, 1, true, {
+        handlerId,
+    });
+    ldsMobileInstrumentation.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.incrementCounter(DRAFT_QUEUE_STATE_STARTED);
+            break;
+        case 'error':
+            ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_STATE_ERROR, 1, true);
+            break;
+        case 'waiting':
+            ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_STATE_WAITING);
+            break;
+        case 'stopped':
+            ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_STATE_STOPPED);
+            break;
+    }
+}
+function reportDraftAwareContentDocumentVersionSynthesizeError(err) {
+    let error;
+    if (err.body !== undefined) {
+        error = err.body;
+    }
+    else {
+        error = normalizeError(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.incrementCounter(CREATE_CONTENT_DOCUMENT_AND_VERSION_DRAFT_SYNTHESIZE_ERROR, 1, true, tags);
+    // Log
+    ldsMobileInstrumentation.error(error, errorCode);
+}
+function reportDraftAwareContentVersionSynthesizeCalls(mimeType) {
+    ldsMobileInstrumentation.incrementCounter(CREATE_CONTENT_DOCUMENT_AND_VERSION_TOTAL_SYNTHESIZE_CALLS, 1, undefined, { mimeType });
+}
+/** Priming */
+function reportPrimingSessionCreated() {
+    ldsMobileInstrumentation.incrementCounter(PRIMING_TOTAL_SESSION_COUNT, 1, undefined, {});
+}
+function reportPrimingError(errorType, recordCount) {
+    ldsMobileInstrumentation.incrementCounter(PRIMING_TOTAL_ERROR_COUNT, recordCount, undefined, {
+        errorType,
+    });
+}
+function reportPrimingSuccess(recordCount) {
+    ldsMobileInstrumentation.incrementCounter(PRIMING_TOTAL_PRIMED_COUNT, recordCount, undefined);
+}
+function reportPrimingConflict(resolutionType, recordCount) {
+    ldsMobileInstrumentation.incrementCounter(PRIMING_TOTAL_CONFLICT_COUNT, recordCount, undefined, {
+        resolutionType,
+    });
+}
+/** Network */
+function reportChunkCandidateUrlLength(urlLength) {
+    const buckets = [8000, 10000, 12000, 14000, 16000];
+    ldsMobileInstrumentation.bucketValue('chunk-candidate-url-length-histogram', urlLength, buckets);
+}
+/** Garbage Collection */
+function reportAggressiveTrimTriggered(trimCount, beforeTrimRecordCount, totalRecordsTrimmed) {
+    ldsMobileInstrumentation.trackValue(GARBAGE_COLLECTION_AGGRESSIVE_TRIM_COUNT, trimCount);
+    ldsMobileInstrumentation.trackValue(GARBAGE_COLLECTION_AGGRESSIVE_TRIM_TOTAL_RECORDS_BEFORE_TRIM, beforeTrimRecordCount);
+    ldsMobileInstrumentation.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.trackValue(ONESTORE_CACHE_PURGING_RECORDS_PURGED, recordsPurged);
+}
+function reportOneStoreCachePurgingError(error) {
+    const errorMessage = normalizeError(error);
+    ldsMobileInstrumentation.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';
@@ -42180,10 +42512,10 @@ class AbstractResourceRequestActionHandler {
         // determined by Server setup.
         this.isIdempotencySupported = true;
     }
-    enqueue(data) {
-        return this.draftQueue.enqueue(this.handlerId, data);
+    enqueue(data, observabilityContext) {
+        return this.draftQueue.enqueue(this.handlerId, data, observabilityContext);
     }
-    async buildPendingAction(request, queue) {
+    async buildPendingAction(request, queue, observabilityContext) {
         const targetId = await this.getIdFromRequest(request);
         const tag = this.buildTagForTargetId(targetId);
         const handlerActions = queue.filter((x) => x.handler === this.handlerId);
@@ -42203,13 +42535,16 @@ class AbstractResourceRequestActionHandler {
             timestamp: Date.now(),
             metadata: {},
             version: '242.0.0',
+            observabilityContext,
         };
     }
     async handleAction(action, actionCompleted, actionErrored) {
         const { data: request } = action;
-        // no context is stored in draft action
+        const dispatchOptions = action.observabilityContext !== undefined
+            ? { requestCorrelator: { observabilityContext: action.observabilityContext } }
+            : {};
         try {
-            const response = await this.networkAdapter(request, {});
+            const response = await this.networkAdapter(request, dispatchOptions);
             if (response.ok) {
                 await actionCompleted({
                     ...action,
@@ -42287,20 +42622,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);
@@ -42464,6 +42868,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 {
@@ -42489,6 +42900,17 @@ class AbstractResourceRequestActionHandler {
             timestamp: targetTimestamp,
             id: targetId,
         };
+        // The merged action retains the target's observabilityContext, not the source's.
+        // Attribution belongs to the user action that first enqueued the target draft; the
+        // source's context (if any) is intentionally discarded. If the target had no context
+        // when it was enqueued, the merged action has none — we do not promote the source's
+        // context as a fallback.
+        if (targetAction.observabilityContext !== undefined) {
+            merged.observabilityContext = targetAction.observabilityContext;
+        }
+        else {
+            delete merged.observabilityContext;
+        }
         // overlay data
         // NOTE: we stick to the target's ResourceRequest properties (except body
         // which is merged) because we don't want to overwrite a POST with a PATCH
@@ -42503,6 +42925,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;
@@ -42636,9 +43063,9 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
     setSideEffectHooks(hooks) {
         this.sideEffectHooks = hooks;
     }
-    async buildPendingAction(request, queue) {
+    async buildPendingAction(request, queue, observabilityContext) {
         const resolvedRequest = this.resolveResourceRequest(request);
-        let pendingAction = (await super.buildPendingAction(resolvedRequest, queue));
+        let pendingAction = (await super.buildPendingAction(resolvedRequest, queue, observabilityContext));
         const { tag, targetId } = pendingAction;
         const targetApiName = await this.getApiNameForRecordId(targetId, tag, resolvedRequest);
         pendingAction.metadata[LDS_ACTION_METADATA_API_NAME] = targetApiName;
@@ -43081,10 +43508,10 @@ class AbstractQuickActionHandler extends AbstractResourceRequestActionHandler {
     constructor(draftQueue, networkAdapter, getLuvio, recordService) {
         super(draftQueue, networkAdapter, getLuvio, recordService);
     }
-    async buildPendingAction(request, queue) {
+    async buildPendingAction(request, queue, observabilityContext) {
         this.resolveResourceRequestBody(request.body);
         // eslint-disable-next-line no-return-await
-        return await super.buildPendingAction(request, queue);
+        return await super.buildPendingAction(request, queue, observabilityContext);
     }
     resolveResourceRequestBody(body) {
         let contextId = body.contextId;
@@ -43114,231 +43541,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(err) {
-    if (err instanceof Error) {
-        return err;
-    }
-    else if (typeof err === 'string') {
-        return new Error(err);
-    }
-    return new Error(stringify$5(err));
-}
-
-const O11Y_NAMESPACE_LDS_MOBILE = 'lds-mobile';
-// 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 = getInstrumentation(O11Y_NAMESPACE_LDS_MOBILE);
-const nimbusLogger = typeof __nimbus !== 'undefined' &&
-    __nimbus.plugins !== undefined &&
-    __nimbus.plugins.JSLoggerPlugin !== undefined
-    ? __nimbus.plugins.JSLoggerPlugin
-    : undefined;
-function reportGraphqlQueryParseError(err) {
-    const error = normalizeError(err);
-    const errorCode = GRAPHQL_QUERY_PARSE_ERROR;
-    // Metric
-    reportGraphqlAdapterError(errorCode);
-    // Log
-    ldsMobileInstrumentation.error(error, errorCode);
-}
-function reportGraphqlSqlEvalPreconditionError(err) {
-    const error = normalizeError(err);
-    const errorCode = GRAPHQL_SQL_EVAL_PRECONDITION_ERROR;
-    // Metric
-    reportGraphqlAdapterError(errorCode);
-    // Log
-    ldsMobileInstrumentation.error(error, errorCode);
-}
-function reportGraphqlCreateSnapshotError(err) {
-    const error = normalizeError(err);
-    const errorCode = GRAPHQL_CREATE_SNAPSHOT_ERROR;
-    // Metric
-    reportGraphqlAdapterError(errorCode);
-    // Log
-    ldsMobileInstrumentation.error(error, errorCode);
-}
-function reportGraphQlEvalDbReadDuration(duration) {
-    ldsMobileInstrumentation.trackValue(GRAPHQL_EVAL_DB_READ_DURATION, duration);
-}
-function reportGraphqlAdapterError(errorCode) {
-    // Increment overall count with errorCode as tag
-    ldsMobileInstrumentation.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.bucketValue(GRAPHQL_EVAL_ROOT_QUERY_COUNT, data.rootQueryCount, queryBuckets);
-    ldsMobileInstrumentation.bucketValue(GRAPHQL_EVAL_TOTAL_QUERY_COUNT, data.totalQueryCount, queryBuckets);
-    ldsMobileInstrumentation.bucketValue(GRAPHQL_EVAL_MAX_CHILD_RELATIONSHIPS_COUNT, data.maxChildRelationships, queryBuckets);
-    ldsMobileInstrumentation.bucketValue(GRAPHQL_EVAL_QUERY_RECORD_COUNT, data.requestedRecordCount, recordBuckets);
-}
-function incrementGraphQLRefreshUndfined() {
-    ldsMobileInstrumentation.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.incrementCounter(DRAFT_QUEUE_ACTION_ADDED);
-            break;
-        case 'uploading':
-            ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_ACTION_UPLOADING);
-            break;
-        case 'completed':
-            ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_ACTION_COMPLETED);
-            break;
-        case 'deleted':
-            ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_ACTION_DELETED);
-            break;
-        case 'failed':
-            ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_ACTION_FAILED, 1, true);
-            break;
-        case 'updated':
-            ldsMobileInstrumentation.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.incrementCounter(DRAFT_QUEUE_STATE_STARTED);
-            break;
-        case 'error':
-            ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_STATE_ERROR, 1, true);
-            break;
-        case 'waiting':
-            ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_STATE_WAITING);
-            break;
-        case 'stopped':
-            ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_STATE_STOPPED);
-            break;
-    }
-}
-function reportDraftAwareContentDocumentVersionSynthesizeError(err) {
-    let error;
-    if (err.body !== undefined) {
-        error = err.body;
-    }
-    else {
-        error = normalizeError(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.incrementCounter(CREATE_CONTENT_DOCUMENT_AND_VERSION_DRAFT_SYNTHESIZE_ERROR, 1, true, tags);
-    // Log
-    ldsMobileInstrumentation.error(error, errorCode);
-}
-function reportDraftAwareContentVersionSynthesizeCalls(mimeType) {
-    ldsMobileInstrumentation.incrementCounter(CREATE_CONTENT_DOCUMENT_AND_VERSION_TOTAL_SYNTHESIZE_CALLS, 1, undefined, { mimeType });
-}
-/** Priming */
-function reportPrimingSessionCreated() {
-    ldsMobileInstrumentation.incrementCounter(PRIMING_TOTAL_SESSION_COUNT, 1, undefined, {});
-}
-function reportPrimingError(errorType, recordCount) {
-    ldsMobileInstrumentation.incrementCounter(PRIMING_TOTAL_ERROR_COUNT, recordCount, undefined, {
-        errorType,
-    });
-}
-function reportPrimingSuccess(recordCount) {
-    ldsMobileInstrumentation.incrementCounter(PRIMING_TOTAL_PRIMED_COUNT, recordCount, undefined);
-}
-function reportPrimingConflict(resolutionType, recordCount) {
-    ldsMobileInstrumentation.incrementCounter(PRIMING_TOTAL_CONFLICT_COUNT, recordCount, undefined, {
-        resolutionType,
-    });
-}
-/** Network */
-function reportChunkCandidateUrlLength(urlLength) {
-    const buckets = [8000, 10000, 12000, 14000, 16000];
-    ldsMobileInstrumentation.bucketValue('chunk-candidate-url-length-histogram', urlLength, buckets);
-}
-/** Garbage Collection */
-function reportAggressiveTrimTriggered(trimCount, beforeTrimRecordCount, totalRecordsTrimmed) {
-    ldsMobileInstrumentation.trackValue(GARBAGE_COLLECTION_AGGRESSIVE_TRIM_COUNT, trimCount);
-    ldsMobileInstrumentation.trackValue(GARBAGE_COLLECTION_AGGRESSIVE_TRIM_TOTAL_RECORDS_BEFORE_TRIM, beforeTrimRecordCount);
-    ldsMobileInstrumentation.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.trackValue(ONESTORE_CACHE_PURGING_RECORDS_PURGED, recordsPurged);
-}
-function reportOneStoreCachePurgingError(error) {
-    const errorMessage = normalizeError(error);
-    ldsMobileInstrumentation.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) {
@@ -43518,6 +43720,18 @@ function isCreateContentDocumentAndVersionDraftAdapterEvent(customEvent) {
     return customEvent.namespace === CONTENT_DOCUMENT_AND_VERSION_NAMESPACE;
 }
 
+/**
+ * lds-worker-api packs the user action's ObservabilityContext into
+ * `requestContext.requestCorrelator = { observabilityContext }`. This helper
+ * unwraps it for draft-aware adapter wrappers, which forward the context to
+ * the action handler so retry network spans can be parented to the
+ * originating user action.
+ */
+function extractObservabilityContext(requestContext) {
+    const correlator = requestContext?.requestCorrelator;
+    return correlator?.observabilityContext;
+}
+
 function chunkToBase64(chunk) {
     const bytes = new Uint8Array(chunk);
     const CHUNK_SIZE = 64 * 1024; // 64kb, any bigger and fromCharCode() can error out with an overflow.
@@ -43600,7 +43814,10 @@ function createContentDocumentAndVersionDraftAdapterFactory(luvio, binaryStore,
         if (actionHandler.hasIdempotencySupport()) {
             resourceRequest.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
         }
-        const action = await actionHandler.enqueue(resourceRequest).catch(async (error) => {
+        const observabilityContext = extractObservabilityContext(requestContext);
+        const action = await actionHandler
+            .enqueue(resourceRequest, observabilityContext)
+            .catch(async (error) => {
             eventEmitter({
                 type: 'create-content-document-and-version-synthesized-response-error',
                 handle,
@@ -43701,8 +43918,8 @@ class ContentDocumentCompositeRepresentationActionHandler extends AbstractResour
         this.handlerId = HANDLER_ID;
         draftRecordService.registerRecordHandler(this);
     }
-    async buildPendingAction(request, queue) {
-        const pendingAction = (await super.buildPendingAction(request, queue));
+    async buildPendingAction(request, queue, observabilityContext) {
+        const pendingAction = (await super.buildPendingAction(request, queue, observabilityContext));
         const { targetId } = pendingAction;
         // remember ContentDocument ID
         pendingAction.metadata[CONTENT_DOCUMENT_DRAFT_ID_KEY] = targetId;
@@ -43966,21 +44183,23 @@ function getDescriptionFromResourceRequest(request) {
     return undefined;
 }
 
-/* istanbul ignore file - covered by integration tests */
 /**
  * @param luvio The runtime's luvio instance
  * @param actionHandler The UIAPI Record action handler. NOTE: this adapter doesn't
  *        register it with the DraftQueue, runtime should set that up
  */
 function createRecordDraftAdapterFactory(actionHandler, durableRecordStore) {
-    return async function createRecordDraftAdapter(config, createResourceRequest) {
+    return async function createRecordDraftAdapter(config, createResourceRequest, requestContext) {
         const request = createResourceRequest(config);
         if (actionHandler.hasIdempotencySupport()) {
             request.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
         }
         request.queryParams = request.queryParams || {};
         request.queryParams['includeFieldsInBody'] = true;
-        const action = await actionHandler.enqueue(request).catch((err) => {
+        const observabilityContext = extractObservabilityContext(requestContext);
+        const action = await actionHandler
+            .enqueue(request, observabilityContext)
+            .catch((err) => {
             throw transformErrorToDraftSynthesisError(err);
         });
         let record = await durableRecordStore.getRecord(action.tag);
@@ -44060,34 +44279,34 @@ function updateRecordDraftAdapterFactory(actionHandler, durableRecordStore, obje
     };
 }
 
-/* istanbul ignore file - covered by integration tests */
 /**
  * @param luvio The runtime's luvio instance
  * @param actionHandler The UIAPI Record action handler. NOTE: this adapter doesn't
  *        register it with the DraftQueue, runtime should set that up
  */
 function deleteRecordDraftAdapterFactory(actionHandler) {
-    return async function deleteRecordDraftAdapter(config, buildResourceRequest) {
+    return async function deleteRecordDraftAdapter(config, buildResourceRequest, requestContext) {
         const request = buildResourceRequest(config);
         if (actionHandler.hasIdempotencySupport()) {
             request.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
         }
-        await actionHandler.enqueue(request).catch((err) => {
+        const observabilityContext = extractObservabilityContext(requestContext);
+        await actionHandler.enqueue(request, observabilityContext).catch((err) => {
             throw transformErrorToDraftSynthesisError(err);
         });
     };
 }
 
-/* istanbul ignore file - covered by integration tests */
 /**
  * @param luvio The runtime's luvio instance
  * @param actionHandler The UIAPI Record action handler. NOTE: this adapter doesn't
  *        register it with the DraftQueue, runtime should set that up
  */
 function performQuickActionDraftAdapterFactory(actionHandler, userId) {
-    return async function performQuickActionDraftAdapter(config, createResourceRequest) {
+    return async function performQuickActionDraftAdapter(config, createResourceRequest, requestContext) {
         const request = createResourceRequest(config);
-        const action = await actionHandler.enqueue(request).catch((err) => {
+        const observabilityContext = extractObservabilityContext(requestContext);
+        const action = await actionHandler.enqueue(request, observabilityContext).catch((err) => {
             const error = transformErrorToDraftSynthesisError(err);
             deepFreeze$1(error);
             throw error;
@@ -44114,16 +44333,18 @@ function performQuickActionDraftAdapterFactory(actionHandler, userId) {
     };
 }
 
-/* istanbul ignore file - covered by integration tests */
 /**
  * @param luvio The runtime's luvio instance
  * @param actionHandler The UIAPI Record action handler. NOTE: this adapter doesn't
  *        register it with the DraftQueue, runtime should set that up
  */
 function performUpdateRecordQuickActionDraftAdapterFactory(actionHandler, userId) {
-    return async function performUpdateRecordQuickActionDraftAdapter(config, createResourceRequest) {
+    return async function performUpdateRecordQuickActionDraftAdapter(config, createResourceRequest, requestContext) {
         const request = createResourceRequest(config);
-        const action = await actionHandler.enqueue(request).catch((err) => {
+        const observabilityContext = extractObservabilityContext(requestContext);
+        const action = await actionHandler
+            .enqueue(request, observabilityContext)
+            .catch((err) => {
             const error = transformErrorToDraftSynthesisError(err);
             deepFreeze$1(error);
             throw error;
@@ -51311,6 +51532,7 @@ function buildNimbusNetworkPluginRequest(resourceRequest, resourceRequestContext
     let observabilityContext = null;
     if (resourceRequestContext !== undefined &&
         resourceRequestContext.requestCorrelator !== undefined &&
+        resourceRequestContext.requestCorrelator !== null &&
         resourceRequestContext.requestCorrelator.observabilityContext !==
             undefined) {
         ({ observabilityContext = null } =
@@ -51909,12 +52131,16 @@ function makeNetworkAdapterChunkRecordFields(networkAdapter, instrumentationSink
  * to a concrete implementation running in jscore.
  */
 class NimbusDraftQueue {
-    enqueue(handlerId, data) {
+    enqueue(handlerId, data, observabilityContext) {
         const callProxyMethod = __nimbus.plugins.LdsDraftQueue.callProxyMethod;
         if (callProxyMethod === undefined) {
             return Promise.reject(new Error('callProxyMethod not defined on the nimbus plugin'));
         }
-        const serializedAction = stringify$5([handlerId, data]);
+        const args = [handlerId, data];
+        if (observabilityContext !== undefined) {
+            args.push(observabilityContext);
+        }
+        const serializedAction = stringify$5(args);
         return new Promise((resolve, reject) => {
             callProxyMethod('enqueue', serializedAction, (serializedActionResponse) => {
                 const response = parse$5(serializedActionResponse);
@@ -56524,7 +56750,9 @@ function buildSubscribableResult$1(result, subscribe, refresh) {
 }
 function resolvedPromiseLike$2(result) {
   if (isPromiseLike$2(result)) {
-    return result.then((nextResult) => nextResult);
+    return result.then(
+      (nextResult) => nextResult
+    );
   }
   return {
     then: (onFulfilled, _onRejected) => {
@@ -56541,7 +56769,9 @@ function resolvedPromiseLike$2(result) {
 }
 function rejectedPromiseLike$2(reason) {
   if (isPromiseLike$2(reason)) {
-    return reason.then((nextResult) => nextResult);
+    return reason.then(
+      (nextResult) => nextResult
+    );
   }
   return {
     then: (_onFulfilled, onRejected) => {
@@ -56587,7 +56817,10 @@ function deepEquals$1(x, y) {
     }
     for (let i = 0; i < xkeys.length; ++i) {
       const key = xkeys[i];
-      if (!deepEquals$1(x[key], y[key])) {
+      if (!deepEquals$1(
+        x[key],
+        y[key]
+      )) {
         return false;
       }
     }
@@ -56595,49 +56828,6 @@ function deepEquals$1(x, y) {
   }
   return x === y;
 }
-function stableJSONStringify(node) {
-  if (node && node.toJSON && typeof node.toJSON === "function") {
-    node = node.toJSON();
-  }
-  if (node === void 0) {
-    return;
-  }
-  if (typeof node === "number") {
-    return isFinite(node) ? "" + node : "null";
-  }
-  if (typeof node !== "object") {
-    return stringify$2(node);
-  }
-  let i;
-  let out;
-  if (isArray$1(node)) {
-    out = "[";
-    for (i = 0; i < node.length; i++) {
-      if (i) {
-        out += ",";
-      }
-      out += stableJSONStringify(node[i]) || "null";
-    }
-    return out + "]";
-  }
-  if (node === null) {
-    return "null";
-  }
-  const objKeys = keys(node).sort();
-  out = "";
-  for (i = 0; i < objKeys.length; i++) {
-    const key = objKeys[i];
-    const value = stableJSONStringify(node[key]);
-    if (!value) {
-      continue;
-    }
-    if (out) {
-      out += ",";
-    }
-    out += stringify$2(key) + ":" + value;
-  }
-  return "{" + out + "}";
-}
 function toError(x) {
   if (x instanceof Error) {
     return x;
@@ -56657,6 +56847,19 @@ var HttpStatusCode = /* @__PURE__ */ ((HttpStatusCode2) => {
   HttpStatusCode2[HttpStatusCode2["GatewayTimeout"] = 504] = "GatewayTimeout";
   return HttpStatusCode2;
 })(HttpStatusCode || {});
+function getFetchResponseFromAuraError(err2) {
+  const auraError = err2;
+  if (auraError.data !== void 0 && auraError.data.statusCode !== void 0) {
+    const data = auraError.data;
+    if (auraError.id !== void 0) {
+      data.id = auraError.id;
+    }
+    return new FetchResponse(data.statusCode, data);
+  }
+  return new FetchResponse(500, {
+    error: err2?.message
+  });
+}
 function getStatusText(status) {
   switch (status) {
     case 200:
@@ -56696,9 +56899,10 @@ function deepFreeze(value) {
       deepFreeze(value[i]);
     }
   } else {
-    const keys$1 = keys(value);
+    const record = value;
+    const keys$1 = keys(record);
     for (let i = 0, len = keys$1.length; i < len; i += 1) {
-      deepFreeze(value[keys$1[i]]);
+      deepFreeze(record[keys$1[i]]);
     }
   }
   freeze(value);
@@ -56772,7 +56976,7 @@ let NetworkCommand$1 = class NetworkCommand extends BaseCommand {
   async afterRequestHooks(_options) {
   }
 };
-function buildServiceDescriptor$n() {
+function buildServiceDescriptor$m() {
   return {
     type: "networkCommandBaseClass",
     version: "1.0",
@@ -56798,7 +57002,7 @@ class AuraNetworkCommand extends NetworkCommand$1 {
     );
   }
   coerceAuraErrors(auraErrors) {
-    return toError(auraErrors[0]);
+    return new UserVisibleError(getFetchResponseFromAuraError(auraErrors[0]));
   }
   /**
    * Customize how non-2xx fetch fallback responses are converted into errors.
@@ -56878,7 +57082,7 @@ class AuraNetworkCommand extends NetworkCommand$1 {
     return resolvedPromiseLike$2(err$1(toError("Aura/Fetch network services not found")));
   }
 }
-function buildServiceDescriptor$m() {
+function buildServiceDescriptor$l() {
   return {
     type: "auraNetworkCommandBaseClass",
     version: "1.0",
@@ -56920,7 +57124,9 @@ function buildSubscribableResult(result, subscribe, refresh) {
 }
 function resolvedPromiseLike$1(result) {
   if (isPromiseLike$1(result)) {
-    return result.then((nextResult) => nextResult);
+    return result.then(
+      (nextResult) => nextResult
+    );
   }
   return {
     then: (onFulfilled, _onRejected) => {
@@ -56937,7 +57143,9 @@ function resolvedPromiseLike$1(result) {
 }
 function rejectedPromiseLike$1(reason) {
   if (isPromiseLike$1(reason)) {
-    return reason.then((nextResult) => nextResult);
+    return reason.then(
+      (nextResult) => nextResult
+    );
   }
   return {
     then: (_onFulfilled, onRejected) => {
@@ -56983,7 +57191,10 @@ function deepEquals(x, y) {
     }
     for (let i = 0; i < xkeys.length; ++i) {
       const key = xkeys[i];
-      if (!deepEquals(x[key], y[key])) {
+      if (!deepEquals(
+        x[key],
+        y[key]
+      )) {
         return false;
       }
     }
@@ -57428,7 +57639,7 @@ function mergeCacheControlConfigs(baseConfig, overrides) {
   };
 }
 
-let AuraCacheControlCommand$1 = class AuraCacheControlCommand extends CacheControlCommand {
+class AuraCacheControlCommand extends CacheControlCommand {
   constructor(services) {
     super(services);
     this.services = services;
@@ -57530,8 +57741,8 @@ let AuraCacheControlCommand$1 = class AuraCacheControlCommand extends CacheContr
       (reason) => err$1(toError(reason))
     );
   }
-};
-class AuraNormalizedCacheControlCommand extends AuraCacheControlCommand$1 {
+}
+class AuraNormalizedCacheControlCommand extends AuraCacheControlCommand {
   constructor(services) {
     super(services);
     this.services = services;
@@ -57555,7 +57766,7 @@ class AuraNormalizedCacheControlCommand extends AuraCacheControlCommand$1 {
     return resolvedPromiseLike$2(void 0);
   }
 }
-function buildServiceDescriptor$l() {
+function buildServiceDescriptor$k() {
   return {
     type: "auraNormalizedCacheControlCommand",
     version: "1.0",
@@ -57563,144 +57774,6 @@ function buildServiceDescriptor$l() {
   };
 }
 
-class AuraCacheControlCommand extends CacheControlCommand {
-  constructor(services) {
-    super(services);
-    this.services = services;
-    this.actionConfig = {
-      background: false,
-      hotspot: true,
-      longRunning: false,
-      storable: false
-    };
-    this.networkPreference = "aura";
-  }
-  get fetchParams() {
-    throw new Error(
-      "Fetch parameters must be specified when using HTTP transport on an Aura adapter"
-    );
-  }
-  shouldUseAuraNetwork() {
-    return this.services.auraNetwork !== void 0 && (this.networkPreference === "aura" || !this.services.fetch);
-  }
-  shouldUseFetch() {
-    return this.services.fetch !== void 0 && (this.networkPreference === "http" || !this.services.auraNetwork);
-  }
-  requestFromNetwork() {
-    if (this.shouldUseAuraNetwork()) {
-      return this.convertAuraResponseToData(
-        this.services.auraNetwork(this.endpoint, this.auraParams, this.actionConfig),
-        (errs) => this.coerceAuraErrors(errs)
-      );
-    } else if (this.shouldUseFetch()) {
-      const params = this.fetchParams;
-      try {
-        return this.convertFetchResponseToData(this.services.fetch(...params));
-      } catch (reason) {
-        return resolvedPromiseLike$2(err$1(toError(reason)));
-      }
-    }
-    return resolvedPromiseLike$2(err$1(toError("Aura/Fetch network services not found")));
-  }
-  coerceAuraErrors(auraErrors) {
-    return toError(auraErrors[0]);
-  }
-  async coerceError(errorResponse) {
-    return toError(errorResponse.statusText);
-  }
-  processAuraReturnValue(auraReturnValue) {
-    return ok$1(auraReturnValue);
-  }
-  processFetchReturnValue(json) {
-    return ok$1(json);
-  }
-  convertAuraResponseToData(responsePromise, coerceError) {
-    return responsePromise.then((response) => {
-      return this.processAuraReturnValue(response.getReturnValue());
-    }).finally(() => {
-      try {
-        this.afterRequestHooks({ statusCode: 200 });
-      } catch {
-      }
-    }).catch((error) => {
-      if (!error) {
-        return err$1(toError("Failed to get error from response"));
-      }
-      if (!error.getError) {
-        return err$1(toError(error));
-      }
-      const actionErrors = error.getError();
-      if (actionErrors.length > 0) {
-        return err$1(coerceError(actionErrors));
-      }
-      return err$1(toError("Error fetching component"));
-    });
-  }
-  convertFetchResponseToData(response) {
-    return response.then(
-      (response2) => {
-        if (response2.ok) {
-          return response2.json().then(
-            (json) => {
-              return this.processFetchReturnValue(json);
-            },
-            (reason) => err$1(toError(reason))
-          ).finally(() => {
-            try {
-              this.afterRequestHooks({ statusCode: response2.status });
-            } catch {
-            }
-          });
-        } else {
-          return this.coerceError(response2).then((coercedError) => {
-            return err$1(coercedError);
-          }).finally(() => {
-            try {
-              this.afterRequestHooks({ statusCode: response2.status });
-            } catch {
-            }
-          });
-        }
-      },
-      (reason) => err$1(toError(reason))
-    );
-  }
-}
-class AuraResourceCacheControlCommand extends AuraCacheControlCommand {
-  constructor(services) {
-    super(services);
-    this.services = services;
-  }
-  readFromCache(cache) {
-    const data = cache.get(this.buildKey())?.value;
-    if (data === void 0) {
-      return resolvedPromiseLike$2(err$1(new Error("Failed to find data in cache")));
-    }
-    return resolvedPromiseLike$2(ok$1(data));
-  }
-  writeToCache(cache, networkResult) {
-    if (networkResult.isOk()) {
-      cache.set(this.buildKey(), {
-        value: networkResult.value,
-        metadata: {
-          cacheControl: this.buildCacheControlMetadata(networkResult.value)
-        }
-      });
-    }
-    return resolvedPromiseLike$2(void 0);
-  }
-  buildKey() {
-    return `{"endpoint":${this.endpoint},"params":${stableJSONStringify(this.auraParams)}}`;
-  }
-}
-function buildServiceDescriptor$k() {
-  return {
-    type: "auraResourceCacheControlCommand",
-    version: "1.0",
-    service: AuraResourceCacheControlCommand
-  };
-}
-
 class NetworkCommand extends BaseCommand {
   constructor(services) {
     super();
@@ -57744,16 +57817,16 @@ class NetworkCommand extends BaseCommand {
   }
 }
 function isAbortableCommand(command) {
-  return "isAbortableCommand" in command && command.isAbortableCommand === true;
+  return !!command && typeof command === "object" && "isAbortableCommand" in command && command.isAbortableCommand === true;
 }
 function hasFetchParams(command) {
-  return command && typeof command === "object" && "fetchParams" in command;
+  return !!command && typeof command === "object" && "fetchParams" in command;
 }
 function createAbortableDecorator(command, options) {
-  if (!options?.signal || !(options?.signal instanceof AbortSignal)) {
+  const signal = options?.signal;
+  if (!signal || !(signal instanceof AbortSignal)) {
     return command;
   }
-  const { signal } = options;
   if (isAbortableCommand(command)) {
     if (process.env.NODE_ENV !== "production") {
       console.warn(
@@ -57764,14 +57837,15 @@ function createAbortableDecorator(command, options) {
   }
   if (!hasFetchParams(command)) {
     if (process.env.NODE_ENV !== "production") {
+      const commandName = typeof command === "object" && command !== null ? command.constructor.name : typeof command;
       console.warn(
-        `Command ${command.constructor.name} does not support fetch operations. AbortSignal will be ignored.`
+        `Command ${commandName} does not support fetch operations. AbortSignal will be ignored.`
       );
     }
     return command;
   }
   try {
-    return new Proxy(command, {
+    const handler = {
       get(target, prop, receiver) {
         if (prop === "isAbortableCommand") {
           return true;
@@ -57780,8 +57854,8 @@ function createAbortableDecorator(command, options) {
           return signal;
         }
         if (prop === "fetchParams") {
-          const originalFetchParams = target[prop];
-          const isInternal = target.isInternalExecution === true;
+          const originalFetchParams = Reflect.get(target, prop, receiver);
+          const isInternal = Reflect.get(target, "isInternalExecution", receiver) === true;
           if (typeof originalFetchParams === "function") {
             return function(...args) {
               const originalReturnValue = originalFetchParams.apply(this, args);
@@ -57807,7 +57881,8 @@ function createAbortableDecorator(command, options) {
         }
         return Reflect.has(target, prop);
       }
-    });
+    };
+    return new Proxy(command, handler);
   } catch (error) {
     if (process.env.NODE_ENV !== "production") {
       console.error(
@@ -58902,7 +58977,7 @@ function buildServiceDescriptor$b(luvio) {
         },
     };
 }
-// version: 1.443.0-be70f6bb6e
+// version: 1.445.0-117c9de71a
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -58928,7 +59003,7 @@ function buildServiceDescriptor$a(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.443.0-be70f6bb6e
+// version: 1.445.0-117c9de71a
 
 function findExecutableOperation(input) {
   const operations = input.query.definitions.filter(
@@ -59728,7 +59803,7 @@ function findSchemaAtPath(document, ref) {
   let path = "#";
   for (const key of keys) {
     path = `${path}/${key}`;
-    if (current[key] === void 0) {
+    if (typeof current !== "object" || current === null || current[key] === void 0) {
       throw new InvalidRefError(
         `Invalid $ref value '${ref}'. Cannot find target schema at '${path}'`
       );
@@ -59968,7 +60043,10 @@ class GraphQLImperativeBindingsService {
           const options = {
             acceptedOperations: ["query"]
           };
-          const result = resolveAndValidateGraphQLConfig(params[0], options);
+          const result = resolveAndValidateGraphQLConfig(
+            params[0],
+            options
+          );
           if (result?.isErr()) {
             return result.error;
           }
@@ -60165,7 +60243,10 @@ class GraphQLMutationBindingsService {
           const options = {
             acceptedOperations: ["mutation"]
           };
-          const result2 = resolveAndValidateGraphQLConfig(params[0], options);
+          const result2 = resolveAndValidateGraphQLConfig(
+            params[0],
+            options
+          );
           if (result2?.isErr()) {
             return {
               data: void 0,
@@ -60785,7 +60866,9 @@ function addAllToSet(targetSet, sourceSet) {
 }
 function resolvedPromiseLike(result) {
   if (isPromiseLike(result)) {
-    return result.then((nextResult) => nextResult);
+    return result.then(
+      (nextResult) => nextResult
+    );
   }
   return {
     then: (onFulfilled, _onRejected) => {
@@ -60802,7 +60885,9 @@ function resolvedPromiseLike(result) {
 }
 function rejectedPromiseLike(reason) {
   if (isPromiseLike(reason)) {
-    return reason.then((nextResult) => nextResult);
+    return reason.then(
+      (nextResult) => nextResult
+    );
   }
   return {
     then: (_onFulfilled, onRejected) => {
@@ -61324,12 +61409,11 @@ function initializeOneStore(sqliteStore, luvio) {
         buildNimbusFetchServiceDescriptor(),
         buildServiceDescriptor$f(instrumentationServiceDescriptor.service),
         // NOTE: These do not directly depend on Aura, and are necessary for HTTP fallback support.
-        buildServiceDescriptor$m(),
         buildServiceDescriptor$l(),
         buildServiceDescriptor$k(),
         buildServiceDescriptor$g(cacheServiceDescriptor.service, nimbusSqliteOneStoreCacheServiceDescriptor.service, instrumentationServiceDescriptor.service),
         buildServiceDescriptor$j(),
-        buildServiceDescriptor$n(),
+        buildServiceDescriptor$m(),
         buildServiceDescriptor$i(),
         buildServiceDescriptor$d(),
         buildServiceDescriptor$9(),
@@ -61608,4 +61692,4 @@ register({
 });
 
 export { O11Y_NAMESPACE_LDS_MOBILE, getRuntime, ingest$1o as ingestDenormalizedRecordRepresentation, initializeOneStore, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.443.0-be70f6bb6e
+// version: 1.445.0-117c9de71a