@salesforce/lds-worker-api 1.454.0 → 1.456.0

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

@@ -4282,7 +4282,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.454.0-4223ab4365
+    // version: 1.456.0-cef836b978
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -5326,7 +5326,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.454.0-4223ab4365
+    // version: 1.456.0-cef836b978
 
     function isSupportedEntity(_objectApiName) {
         return true;
@@ -5436,7 +5436,7 @@
 
     const { keys: ObjectKeys$4, create: ObjectCreate$4 } = Object;
 
-    const { assign: assign$7, create: create$9, freeze: freeze$6, isFrozen: isFrozen$4, keys: keys$a } = Object;
+    const { assign: assign$7, create: create$9, freeze: freeze$6, getPrototypeOf: getPrototypeOf$3, isFrozen: isFrozen$4, keys: keys$a } = Object;
 
     /**
      * Defines configuration for the module with a default value which can be overridden by the runtime environment.
@@ -6071,7 +6071,7 @@
     }
     const keyPrefix$3 = 'UiApi';
 
-    const { assign: assign$6, create: create$8, freeze: freeze$5, isFrozen: isFrozen$3, keys: keys$9 } = Object;
+    const { assign: assign$6, create: create$8, freeze: freeze$5, getPrototypeOf: getPrototypeOf$2, isFrozen: isFrozen$3, keys: keys$9 } = Object;
     const { hasOwnProperty: hasOwnProperty$5 } = Object.prototype;
     const { split: split$1, endsWith: endsWith$1 } = String.prototype;
     const { isArray: isArray$8 } = Array;
@@ -32553,7 +32553,7 @@
         throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
         throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
     });
-    // version: 1.454.0-761808c4e9
+    // version: 1.456.0-6ed480b93c
 
     var draftQueueMaxRetryAttemptsGate = {
         isOpen: function (e) {
@@ -47855,16 +47855,18 @@
     }
 
     class AsyncWorkerPool {
-        constructor(concurrency) {
+        constructor(concurrency, onWorkTiming) {
             this.queue = [];
             this.activeWork = [];
             this.concurrency = concurrency;
+            this.onWorkTiming = onWorkTiming;
         }
         push(work) {
             return new Promise((resolve, reject) => {
                 this.queue.push({
                     ...work,
                     workFn: (abortController) => work.workFn(abortController).then(resolve).catch(reject),
+                    enqueuedAt: Date.now(),
                 });
                 this.doWork();
             });
@@ -47907,10 +47909,30 @@
                     const abortController = new LdsAbortController();
                     const newWork = { ...work, abortController };
                     this.activeWork.push(newWork);
-                    const { workFn } = work;
+                    const { workFn, enqueuedAt } = work;
+                    const onWorkTiming = this.onWorkTiming;
+                    let startedAt = 0;
+                    let waitMs = 0;
+                    let queueDepthAtStart = 0;
+                    if (onWorkTiming !== undefined) {
+                        startedAt = Date.now();
+                        waitMs = startedAt - enqueuedAt;
+                        // depth AFTER this unit was shifted off — units still waiting behind it.
+                        queueDepthAtStart = this.queue.length;
+                    }
                     workFn(abortController).finally(() => {
-                        this.activeWork = this.activeWork.filter((w) => w !== newWork);
-                        this.doWork();
+                        try {
+                            if (onWorkTiming !== undefined) {
+                                onWorkTiming(waitMs, Date.now() - startedAt, queueDepthAtStart);
+                            }
+                        }
+                        catch {
+                            // Instrumentation must not prevent the pool from releasing the worker slot.
+                        }
+                        finally {
+                            this.activeWork = this.activeWork.filter((w) => w !== newWork);
+                            this.doWork();
+                        }
                     });
                 }
             }
@@ -48240,6 +48262,25 @@
      */
     const DRAFT_ACTION_RETRY_COUNT_METADATA_KEY = 'retryCount';
     class DurableDraftQueue {
+        // Instrumentation is strictly measure-only: a broken sink must never change queue behavior.
+        // Pass the sink into the callback so methods are invoked through their owning object and retain
+        // their receiver (some sinks use `this` to reach their metric registry).
+        emitInstrumentation(emit) {
+            const { instrumentation } = this;
+            if (instrumentation === undefined) {
+                return;
+            }
+            try {
+                emit(instrumentation);
+            }
+            catch {
+                // Telemetry failures must not interrupt draft processing.
+            }
+        }
+        resetDrainCycle() {
+            this.drainCycleStart = undefined;
+            this.drainCycleBatchCount = 0;
+        }
         getHandler(id) {
             const handler = this.handlers[id];
             if (handler === undefined) {
@@ -48262,9 +48303,19 @@
                 ? __nimbus.plugins.JSLoggerPlugin
                 : undefined;
             this.handlers = {};
+            // Drain-wait attribution state. uploadStartTimes stamps when each action first began
+            // uploading (keyed by action id) so actionCompleted/failed can emit its end-to-end drain time,
+            // including automatic retries/backoff. actionQueueWaitEmittedIds ensures those retries do not
+            // report the original enqueue wait more than once. drainCycleStart/BatchCount track one full
+            // idle->empty sweep. All measure-only; when no instrumentation is injected these stay untouched.
+            this.uploadStartTimes = new Map();
+            this.actionQueueWaitEmittedIds = new Set();
+            this.drainCycleBatchCount = 0;
             this.draftStore = draftStore;
-            this.workerPool = new AsyncWorkerPool(1);
             this.instrumentation = instrumentation;
+            this.workerPool = new AsyncWorkerPool(1, instrumentation?.onWorkerTiming !== undefined
+                ? (waitMs, holdMs, queueDepth) => this.emitInstrumentation((sink) => sink.onWorkerTiming?.(waitMs, holdMs, queueDepth))
+                : undefined);
         }
         addHandler(handler) {
             const id = handler.handlerId;
@@ -48352,6 +48403,9 @@
                 clearTimeout(this.timeoutHandler);
                 this.timeoutHandler = undefined;
             }
+            // A stop/user edit breaks the current sweep. A later restart starts a fresh cycle rather
+            // than attributing stopped time to an offline drain.
+            this.resetDrainCycle();
             this.state = DraftQueueState.Stopped;
         }
         async getQueueActions() {
@@ -48382,7 +48436,7 @@
                 }
                 return aTime - bTime;
             });
-            instrumentation?.onGetQueueActions?.(Date.now() - start, sorted.length);
+            this.emitInstrumentation((sink) => sink.onGetQueueActions?.(Date.now() - start, sorted.length));
             return sorted;
         }
         async enqueue(handlerId, data, observabilityContext) {
@@ -48426,6 +48480,13 @@
                     await handler.handleActionCompleted(action, queueOperations, values$2(this.handlers));
                     this.retryIntervalMilliseconds = 0;
                     this.uploadingActionId = undefined;
+                    // The action finished draining — emit its end-to-end drain time and
+                    // count it toward the current drain-cycle batch. Measure-only.
+                    this.emitActionDrainDuration(action.id, action.handler);
+                    this.actionQueueWaitEmittedIds.delete(action.id);
+                    if (this.drainCycleStart !== undefined) {
+                        this.drainCycleBatchCount += 1;
+                    }
                     await this.notifyChangedListeners({
                         type: DraftQueueEventType.ActionCompleted,
                         action,
@@ -48437,6 +48498,16 @@
                 },
             });
         }
+        // Read+clear the action's upload-start stamp and emit its drain duration. Safe to
+        // call when instrumentation is absent or the id was never stamped (no-op). Never emits the id.
+        emitActionDrainDuration(id, handlerId) {
+            const start = this.uploadStartTimes.get(id);
+            if (start === undefined) {
+                return;
+            }
+            this.uploadStartTimes.delete(id);
+            this.emitInstrumentation((sink) => sink.onActionDrainDuration?.(handlerId, Date.now() - start));
+        }
         async actionFailed(action, retry, retryDelayInMs, actionDataChanged) {
             if (actionDataChanged === true) {
                 await this.draftStore.writeAction({
@@ -48446,14 +48517,24 @@
             }
             this.uploadingActionId = undefined;
             if (retry && this.state !== DraftQueueState.Stopped) {
+                // A retry means this action is NOT done draining. Keep its first-upload stamp and the
+                // open cycle so the eventual outcome includes network time and retry/backoff.
                 this.state = DraftQueueState.Waiting;
                 return retryDelayInMs !== undefined
                     ? this.scheduleRetryWithSpecifiedDelay(retryDelayInMs)
                     : this.scheduleRetry();
             }
             else if (isDraftError(action)) {
+                // Terminal failure — this action is done draining. Emit its drain time.
+                this.emitActionDrainDuration(action.id, action.handler);
+                // This was not a clean drain-to-empty. Discard the sweep before user intervention so a
+                // later manual retry/removal cannot inherit its elapsed time or completed batch count.
+                this.resetDrainCycle();
                 return this.handleServerError(action, action.error);
             }
+            // Any other terminal path — ensure no stale start stamp lingers.
+            this.emitActionDrainDuration(action.id, action.handler);
+            this.resetDrainCycle();
         }
         handle(action) {
             const handler = this.getHandler(action.handler);
@@ -48473,12 +48554,22 @@
                     this.state = DraftQueueState.Started;
                 }
                 this.processingAction = undefined;
+                // The queue drained empty — close the drain-cycle window if one was open.
+                if (this.drainCycleStart !== undefined) {
+                    const durationMs = Date.now() - this.drainCycleStart;
+                    const batchSize = this.drainCycleBatchCount;
+                    this.resetDrainCycle();
+                    this.emitInstrumentation((sink) => sink.onDrainCycle?.(durationMs, batchSize));
+                }
                 return ProcessActionResult.NO_ACTION_TO_PROCESS;
             }
             const { status, id } = action;
             if (status === DraftActionStatus.Error) {
                 this.state = DraftQueueState.Error;
                 this.processingAction = undefined;
+                // The sweep is blocked on an errored action, not a clean drain-to-empty —
+                // discard the open drain-cycle window so it doesn't inflate a later cycle's duration.
+                this.resetDrainCycle();
                 await this.notifyChangedListeners({
                     type: DraftQueueEventType.ActionFailed,
                     action: action,
@@ -48496,6 +48587,31 @@
             if (this.state === DraftQueueState.Waiting) {
                 this.state = DraftQueueState.Started;
             }
+            // The action is now leaving the queue to upload. Emit head-of-line FIFO wait
+            // (enqueue -> upload start), stamp its drain-start for end-to-end timing on completion, and
+            // open a drain-cycle window if the queue was previously idle. All measure-only.
+            const { instrumentation } = this;
+            if (instrumentation !== undefined) {
+                const now = Date.now();
+                const { timestamp } = action;
+                if (instrumentation.onActionQueueWait !== undefined &&
+                    !this.actionQueueWaitEmittedIds.has(id) &&
+                    typeof timestamp === 'number' &&
+                    timestamp > 0) {
+                    // Mark before invoking the sink: even a throwing callback must not make a retry
+                    // report the same action's enqueue wait again.
+                    this.actionQueueWaitEmittedIds.add(id);
+                    this.emitInstrumentation((sink) => sink.onActionQueueWait?.(action.handler, now - timestamp));
+                }
+                if (instrumentation.onActionDrainDuration !== undefined &&
+                    !this.uploadStartTimes.has(id)) {
+                    this.uploadStartTimes.set(id, now);
+                }
+                if (instrumentation.onDrainCycle !== undefined && this.drainCycleStart === undefined) {
+                    this.drainCycleStart = now;
+                    this.drainCycleBatchCount = 0;
+                }
+            }
             await this.notifyChangedListeners({
                 type: DraftQueueEventType.ActionUploading,
                 action: { ...action, status: DraftActionStatus.Uploading },
@@ -48533,7 +48649,7 @@
                 results.push(listener(event));
             }
             // W-23515682: listener fan-out per event type. Measure-only.
-            this.instrumentation?.onNotifyChangedListeners?.(event.type, draftQueueLen);
+            this.emitInstrumentation((sink) => sink.onNotifyChangedListeners?.(event.type, draftQueueLen));
             await Promise.all(results);
         }
         /**
@@ -48562,9 +48678,17 @@
             const shouldDeleteRelated = handler.shouldDeleteActionByTagOnRemoval(action);
             if (shouldDeleteRelated) {
                 await this.draftStore.deleteByTag(action.tag);
+                queue.forEach((queuedAction) => {
+                    if (queuedAction.tag === action.tag) {
+                        this.uploadStartTimes.delete(queuedAction.id);
+                        this.actionQueueWaitEmittedIds.delete(queuedAction.id);
+                    }
+                });
             }
             else {
                 await this.draftStore.deleteDraft(action.id);
+                this.uploadStartTimes.delete(action.id);
+                this.actionQueueWaitEmittedIds.delete(action.id);
             }
             await handler.handleActionRemoved(action, queue.filter((x) => x.id !== actionId));
             await this.notifyChangedListeners({
@@ -80196,6 +80320,20 @@
     const DRAFT_QUEUE_NOTIFY_CHANGED_LISTENERS_COUNT = 'draft-queue-notify-changed-listeners-count';
     const DRAFT_QUEUE_DURABLE_OP_COUNT = 'draft-queue-durable-op-count';
     const DRAFT_QUEUE_DURABLE_OP_DURATION = 'draft-queue-durable-op-duration';
+    // Drain-wait attribution telemetry: the wall-clock spine of where an offline drain actually spends
+    // WAITING. Operational counts/durations/depths only — no draft content, field values, or server
+    // record ids (matching the existing draft-queue privacy stance).
+    const DRAFT_QUEUE_WORKER_WAIT_DURATION = 'draft-queue-worker-wait-duration';
+    const DRAFT_QUEUE_WORKER_HOLD_DURATION = 'draft-queue-worker-hold-duration';
+    const DRAFT_QUEUE_ACTION_QUEUE_WAIT_DURATION = 'draft-queue-action-queue-wait-duration';
+    const DRAFT_QUEUE_ACTION_DRAIN_DURATION = 'draft-queue-action-drain-duration';
+    const DRAFT_QUEUE_DRAIN_CYCLE_DURATION = 'draft-queue-drain-cycle-duration';
+    const DRAFT_QUEUE_DRAIN_CYCLE_BATCH_SIZE = 'draft-queue-drain-cycle-batch-size';
+    const DRAFT_QUEUE_ACTION_NETWORK_DURATION = 'draft-queue-action-network-duration';
+    const DRAFT_QUEUE_ACTION_RETRY_ATTEMPT = 'draft-queue-action-retry-attempt';
+    const DRAFT_QUEUE_SIDEEFFECT_OP_DURATION = 'draft-queue-sideeffect-op-duration';
+    const DRAFT_QUEUE_SIDEEFFECT_MAP_SIZE = 'draft-queue-sideeffect-map-size';
+    const DRAFT_QUEUE_SIDEEFFECT_REGION_DURATION = 'draft-queue-sideeffect-region-duration';
     /** 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';
@@ -80315,6 +80453,134 @@
         });
         ldsMobileInstrumentation$2.trackValue(DRAFT_QUEUE_DURABLE_OP_DURATION, durationMs);
     }
+    const DRAIN_DURATION_BUCKETS = [50, 100, 250, 500, 1000, 2500, 5000, 10000, 30000];
+    const WORKER_DEPTH_BUCKETS = [1, 2, 5, 10, 20, 50, 100, 250, 500];
+    // Handler ids are extensible through DraftManager, so only retain the fixed mobile handlers in
+    // metric tags. Everything else shares one bounded bucket rather than creating an unbounded series.
+    function draftQueueHandlerTagOf(handlerId) {
+        switch (handlerId) {
+            case 'LDS_ACTION_HANDLER':
+            case 'ContentDocumentCompositeRepresentationActionHandler':
+            case 'QUICK_ACTION_HANDLER':
+            case 'UPDATE_RECORD_QUICK_ACTION_HANDLER':
+                return handlerId;
+            default:
+                return 'custom';
+        }
+    }
+    // Coarse, bounded-cardinality label for the pool depth a unit saw when it began, so the
+    // wait/hold durations can be sliced BY backlog size without emitting depth as a free integer tag.
+    function workerDepthBucketOf(queueDepth) {
+        if (queueDepth <= 0) {
+            return '0';
+        }
+        if (queueDepth <= 2) {
+            return '1-2';
+        }
+        if (queueDepth <= 10) {
+            return '3-10';
+        }
+        if (queueDepth <= 50) {
+            return '11-50';
+        }
+        if (queueDepth <= 250) {
+            return '51-250';
+        }
+        return '250+';
+    }
+    /**
+     * Per-unit lifecycle split for the AsyncWorkerPool(1) serial queue, emitted once when a unit settles
+     * so the two halves are a JOINED event (rather than shipping wait and depth as unrelated aggregates).
+     * Isolates WHERE the time goes:
+     *   waitMs — enqueue -> work began (waiting on the serial queue before any logic runs).
+     *   holdMs — work began -> work settled (the critical section's own O(N) service time).
+     * Both are additionally tagged by a depthBucket so "does per-unit cost scale with backlog depth"
+     * (the O(N^2) signature) survives aggregation. queueDepth itself is also tracked. Operational only.
+     */
+    function reportDraftQueueWorkerTiming(waitMs, holdMs, queueDepth) {
+        const depthBucket = workerDepthBucketOf(queueDepth);
+        ldsMobileInstrumentation$2.trackValue(DRAFT_QUEUE_WORKER_WAIT_DURATION, waitMs, undefined, {
+            depthBucket,
+        });
+        ldsMobileInstrumentation$2.trackValue(DRAFT_QUEUE_WORKER_HOLD_DURATION, holdMs, undefined, {
+            depthBucket,
+        });
+        ldsMobileInstrumentation$2.bucketValue(DRAFT_QUEUE_WORKER_WAIT_DURATION + '-depth', queueDepth, WORKER_DEPTH_BUCKETS);
+    }
+    /**
+     * Head-of-line FIFO wait for one draft (enqueue -> upload start), bucketed so the
+     * "does wait grow with backlog depth" (O(N^2)) signal is visible per handler type. Custom handler
+     * ids are normalized to one bounded tag so caller-defined values never become metric dimensions.
+     */
+    function reportDraftQueueActionQueueWait(handlerId, waitMs) {
+        ldsMobileInstrumentation$2.bucketValue(DRAFT_QUEUE_ACTION_QUEUE_WAIT_DURATION, waitMs, DRAIN_DURATION_BUCKETS, undefined, { handlerId: draftQueueHandlerTagOf(handlerId) });
+    }
+    /**
+     * End-to-end drain time for one action (first upload attempt -> completed/failed), including
+     * retry/backoff. Compare it with network-duration and retry-attempt signals to understand the
+     * non-request portion of the drain interval.
+     */
+    function reportDraftQueueActionDrainDuration(handlerId, durationMs) {
+        ldsMobileInstrumentation$2.bucketValue(DRAFT_QUEUE_ACTION_DRAIN_DURATION, durationMs, DRAIN_DURATION_BUCKETS, undefined, { handlerId: draftQueueHandlerTagOf(handlerId) });
+    }
+    /**
+     * One full drain sweep — first action starts uploading -> queue empties. Both raw values share a
+     * bounded batch-size cohort so aggregate duration remains sliceable by the number of actions drained.
+     */
+    function reportDraftQueueDrainCycle(durationMs, batchSize) {
+        const batchSizeBucket = workerDepthBucketOf(batchSize);
+        ldsMobileInstrumentation$2.trackValue(DRAFT_QUEUE_DRAIN_CYCLE_DURATION, durationMs, undefined, {
+            batchSizeBucket,
+        });
+        ldsMobileInstrumentation$2.trackValue(DRAFT_QUEUE_DRAIN_CYCLE_BATCH_SIZE, batchSize, undefined, {
+            batchSizeBucket,
+        });
+    }
+    /**
+     * Server round-trip duration for one upload. Isolates slow-network from CPU-bound
+     * quadratic work — today only a THROWN error is captured, so a slow-but-successful (or slow 4xx/5xx)
+     * response is invisible. Tags: handler type, HTTP method, and a bucketed status class ('2xx'/'4xx'/
+     * '5xx'/'0'). No URL, body, or record id.
+     */
+    function reportDraftQueueActionNetworkDuration(handlerId, method, statusBucket, durationMs) {
+        ldsMobileInstrumentation$2.trackValue(DRAFT_QUEUE_ACTION_NETWORK_DURATION, durationMs, undefined, {
+            handlerId: draftQueueHandlerTagOf(handlerId),
+            method,
+            statusBucket,
+        });
+    }
+    /**
+     * Retry event count. Repeated events identify actions cycling through the drain even when the retry
+     * cap is disabled and an exact attempt number is not persisted. cappedOut marks cap exhaustion.
+     */
+    function reportDraftQueueActionRetryAttempt(handlerId, cappedOut) {
+        ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_RETRY_ATTEMPT, 1, undefined, {
+            handlerId: draftQueueHandlerTagOf(handlerId),
+            cappedOut: String(cappedOut),
+        });
+    }
+    /**
+     * SideEffectStore operation duration + map size. The incremental map sped up the by-KEY lookup but
+     * getEffectsByTag still linearly scans all effects — this measures whether that residual scan is
+     * silently quadratic during churn. op is 'add'|'remove'|'getByTag'; incremental flags the fast path;
+     * mapSize is an integer effect count. No record keys, field names, or field values.
+     */
+    function reportDraftQueueSideEffectOp(op, incremental, durationMs, mapSize) {
+        ldsMobileInstrumentation$2.trackValue(DRAFT_QUEUE_SIDEEFFECT_OP_DURATION, durationMs, undefined, {
+            op,
+            incremental: String(incremental),
+        });
+        ldsMobileInstrumentation$2.trackValue(DRAFT_QUEUE_SIDEEFFECT_MAP_SIZE, mapSize, undefined, {
+            op,
+        });
+    }
+    /**
+     * Broad side-effect lifecycle duration. The fixed region and lifecycle tags identify which part of
+     * serialized draft processing is slow without emitting record keys, action ids, or field data.
+     */
+    function reportDraftQueueSideEffectRegionDuration(region, lifecycle, durationMs) {
+        ldsMobileInstrumentation$2.trackValue(DRAFT_QUEUE_SIDEEFFECT_REGION_DURATION, durationMs, undefined, { region, lifecycle });
+    }
     /**
      * 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
@@ -80522,8 +80788,16 @@
             const dispatchOptions = action.observabilityContext !== undefined
                 ? { requestCorrelator: { observabilityContext: action.observabilityContext } }
                 : {};
+            const method = request?.method?.toUpperCase() ?? 'UNKNOWN';
+            const networkStart = Date.now();
+            let responseReceived = false;
             try {
                 const response = await this.networkAdapter(request, dispatchOptions);
+                responseReceived = true;
+                // Time the round-trip regardless of outcome (ok, retryable HTTP error, or non-ok
+                // terminal error) — today only a THROWN error is visible; a slow-but-successful or
+                // slow 4xx/5xx response is not.
+                this.reportNetworkDuration(method, statusBucketOf(response.status), networkStart);
                 if (response.ok) {
                     await actionCompleted({
                         ...action,
@@ -80679,6 +80953,11 @@
                 const error = normalizeError$1(e);
                 const attempt = this.getUploadRetryCount(action) + 1;
                 reportDraftActionUploadError(error, this.handlerId, attempt);
+                // A thrown network call still has a round-trip duration worth surfacing — a slow
+                // FAILING call is otherwise as invisible as a slow successful one.
+                if (!responseReceived) {
+                    this.reportNetworkDuration(method, 'error', networkStart);
+                }
                 await this.retryOrCap(action, error, actionErrored);
                 return ProcessActionResult.NETWORK_ERROR;
             }
@@ -80714,12 +80993,17 @@
          */
         async retryOrCap(action, lastFailure, actionErrored, retryDelayInMs, actionDataChanged) {
             if (!draftQueueMaxRetryAttemptsGate.isOpen({ fallback: false })) {
-                // Gate closed: preserve the pre-existing unbounded-retry behavior exactly.
+                // Gate closed: preserve the pre-existing unbounded-retry behavior exactly. The
+                // metric is still emitted (measure-only) so retry attempts are visible even with
+                // the cap gate closed — cappedOut is always false here since nothing ever caps
+                // out on this path.
+                this.reportRetryAttempt(false);
                 await actionErrored(action, true, retryDelayInMs, actionDataChanged);
                 return;
             }
             const attempt = this.getUploadRetryCount(action) + 1;
             if (attempt >= MAX_RETRY_ATTEMPTS) {
+                this.reportRetryAttempt(true);
                 await actionErrored({
                     ...action,
                     error: buildMaxRetryError(lastFailure),
@@ -80727,6 +81011,7 @@
                 }, false);
                 return;
             }
+            this.reportRetryAttempt(false);
             // 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.
@@ -80740,12 +81025,12 @@
             await actionErrored(retryingAction, true, retryDelayInMs, true);
         }
         async handleActionEnqueued(action) {
-            const impactedKeys = await this.recordService.setSideEffectsForActions([action]);
-            await this.recordService.reapplyRecordSideEffects(impactedKeys);
+            const impactedKeys = await this.recordService.setSideEffectsForActions([action], 'enqueued');
+            await this.recordService.reapplyRecordSideEffects(impactedKeys, 'enqueued');
         }
         async handleActionRemoved(action) {
             const impactedKeys = await this.recordService.removeSideEffectsForAction(action);
-            await this.recordService.reapplyRecordSideEffects(impactedKeys);
+            await this.recordService.reapplyRecordSideEffects(impactedKeys, 'removed');
         }
         async handleActionReplaced(target, source) {
             // remove both the siden effects from the actions being merged before we
@@ -80753,10 +81038,10 @@
             const impactedKeysFromRemove = await this.recordService.removeSideEffectsForAction(source);
             const removedSideEffectFromSet = await this.recordService.removeSideEffectsForAction(target);
             // revert the values in the DEFAULT store back to what it was before the removed side effects
-            await this.recordService.reapplyRecordSideEffects(new Set([...impactedKeysFromRemove, ...removedSideEffectFromSet]));
+            await this.recordService.reapplyRecordSideEffects(new Set([...impactedKeysFromRemove, ...removedSideEffectFromSet]), 'replaced-remove');
             // set the new side effect values for the merged action
-            const impactedKeysFromSet = await this.recordService.setSideEffectsForActions([target]);
-            await this.recordService.reapplyRecordSideEffects(new Set([...impactedKeysFromSet]));
+            const impactedKeysFromSet = await this.recordService.setSideEffectsForActions([target], 'replaced-set');
+            await this.recordService.reapplyRecordSideEffects(new Set([...impactedKeysFromSet]), 'replaced-set');
         }
         async handleActionCompleted(action, queueOperations) {
             const { data: request, tag } = action;
@@ -80790,8 +81075,8 @@
                     actionsNeedingReplay.push(qo.action);
                 }
             });
-            const impactedKeys = await this.recordService.setSideEffectsForActions(actionsNeedingReplay);
-            await this.recordService.reapplyRecordSideEffects(impactedKeys);
+            const impactedKeys = await this.recordService.setSideEffectsForActions(actionsNeedingReplay, 'completed-replay');
+            await this.recordService.reapplyRecordSideEffects(impactedKeys, 'completed-replay');
         }
         getQueueOperationsForCompletingDrafts(queue, action) {
             const queueOperations = [];
@@ -81117,6 +81402,39 @@
                 return new StoreKeyMap();
             });
         }
+        reportNetworkDuration(method, statusBucket, startedAt) {
+            try {
+                reportDraftQueueActionNetworkDuration(this.handlerId, method, statusBucket, Date.now() - startedAt);
+            }
+            catch {
+                // Telemetry must not change upload processing behavior.
+            }
+        }
+        reportRetryAttempt(cappedOut) {
+            try {
+                reportDraftQueueActionRetryAttempt(this.handlerId, cappedOut);
+            }
+            catch {
+                // Telemetry must not change retry or cap behavior.
+            }
+        }
+    }
+    // Classifies an HTTP status into a small, greppable tag set for the network-duration metric —
+    // never the raw status, to keep the metric's tag cardinality bounded.
+    function statusBucketOf(status) {
+        if (status === 0) {
+            return '0';
+        }
+        if (status >= 200 && status <= 299) {
+            return '2xx';
+        }
+        if (status >= 400 && status <= 499) {
+            return '4xx';
+        }
+        if (status >= 500) {
+            return '5xx';
+        }
+        return 'other';
     }
     function actionsForTag(tag, queue) {
         return queue.filter((action) => action.tag === tag);
@@ -81480,10 +81798,16 @@
         }
         // calculates the side effects for a given set of actions
         // and returns a set of impacted record keys
-        async setSideEffectsForActions(changedActions) {
-            const operations = await this.recalculateForChangedActions(changedActions);
-            await this.sideEffectStore.addEffects(operations);
-            return new Set(operations.map((o) => o.key));
+        async setSideEffectsForActions(changedActions, lifecycle) {
+            const startedAt = Date.now();
+            try {
+                const operations = await this.recalculateForChangedActions(changedActions);
+                await this.sideEffectStore.addEffects(operations);
+                return new Set(operations.map((o) => o.key));
+            }
+            finally {
+                this.reportSideEffectRegionDuration('set', lifecycle, startedAt);
+            }
         }
         // removes the associated side effects for a given action and returns
         // a set of impacted record keys
@@ -81494,31 +81818,45 @@
         }
         // reads a set of records out of the durable store, re-applies current side
         // effects and persists the changed record
-        async reapplyRecordSideEffects(recordKeys) {
-            const luvio = this.getLuvio();
-            const keys = Array.from(recordKeys);
-            const recordEntries = await this.durableRecordStore.getRecordsWithMetadata(keys);
-            keys.forEach((key) => {
-                let record;
-                const metadata = {
-                    namespace: 'UiApi',
-                    representationName: 'RecordRepresentation',
-                    version: VERSION$1v$1,
-                    ingestionTimestamp: Date.now(),
-                    ttl: Number.MAX_SAFE_INTEGER,
-                };
-                const recordEntry = recordEntries.get(key);
-                if (recordEntry) {
-                    record = recordEntry.record;
-                    if (recordEntry.metadata) {
-                        metadata.ingestionTimestamp = recordEntry.metadata.ingestionTimestamp;
-                        metadata.ttl = TTL$z;
+        async reapplyRecordSideEffects(recordKeys, lifecycle) {
+            const startedAt = Date.now();
+            try {
+                const luvio = this.getLuvio();
+                const keys = Array.from(recordKeys);
+                const recordEntries = await this.durableRecordStore.getRecordsWithMetadata(keys);
+                keys.forEach((key) => {
+                    let record;
+                    const metadata = {
+                        namespace: 'UiApi',
+                        representationName: 'RecordRepresentation',
+                        version: VERSION$1v$1,
+                        ingestionTimestamp: Date.now(),
+                        ttl: Number.MAX_SAFE_INTEGER,
+                    };
+                    const recordEntry = recordEntries.get(key);
+                    if (recordEntry) {
+                        record = recordEntry.record;
+                        if (recordEntry.metadata) {
+                            metadata.ingestionTimestamp = recordEntry.metadata.ingestionTimestamp;
+                            metadata.ttl = TTL$z;
+                        }
                     }
-                }
-                luvio.storePublish(key, record);
-                luvio.publishStoreMetadata(key, metadata);
-            });
-            await luvio.storeBroadcast();
+                    luvio.storePublish(key, record);
+                    luvio.publishStoreMetadata(key, metadata);
+                });
+                await luvio.storeBroadcast();
+            }
+            finally {
+                this.reportSideEffectRegionDuration('reapply', lifecycle, startedAt);
+            }
+        }
+        reportSideEffectRegionDuration(region, lifecycle, startedAt) {
+            try {
+                reportDraftQueueSideEffectRegionDuration(region, lifecycle, Date.now() - startedAt);
+            }
+            catch {
+                // Telemetry must not change draft processing behavior.
+            }
         }
         async synthesizeId(apiName) {
             const objectInfo = await this.objectInfoService.getObjectInfo(apiName);
@@ -81754,7 +82092,7 @@
             // since we don't ingest a record from the response, we need to manually trigger a re-apply here to ensure we
             // re-ingest the record without effects applied
             await this.recordService.removeSideEffectsForAction(action);
-            await this.recordService.reapplyRecordSideEffects(new Set([action.tag]));
+            await this.recordService.reapplyRecordSideEffects(new Set([action.tag]), 'quick-action-completed');
             // notify luvio that record is now changed and needs to be refreshed
             await luvio.notifyStoreUpdateAvailable([action.tag]);
         }
@@ -90434,6 +90772,18 @@
         onDurableOperation(op, segment, durationMs) {
             reportDraftQueueDurableOperation(op, segment, durationMs);
         },
+        onWorkerTiming(waitMs, holdMs, queueDepth) {
+            reportDraftQueueWorkerTiming(waitMs, holdMs, queueDepth);
+        },
+        onActionQueueWait(handlerId, waitMs) {
+            reportDraftQueueActionQueueWait(handlerId, waitMs);
+        },
+        onActionDrainDuration(handlerId, durationMs) {
+            reportDraftQueueActionDrainDuration(handlerId, durationMs);
+        },
+        onDrainCycle(durationMs, batchSize) {
+            reportDraftQueueDrainCycle(durationMs, batchSize);
+        },
     };
 
     // so eslint doesn't complain about nimbus
@@ -93776,6 +94126,9 @@
             this.initialize();
         }
         async addEffects(effects) {
+            // Wall-clock across the whole method (including the durable write), matching
+            // how the equivalent removeEffects/getEffectsByTag windows are measured.
+            const startTime = Date.now();
             const incremental = draftQueueSideEffectMapGate.isOpen({ fallback: true });
             const durableEntries = {};
             effects.forEach((effect) => {
@@ -93790,8 +94143,11 @@
                 this.regenerateKeyToEffectMap();
             }
             await this.durableStore.setEntries(durableEntries, SIDE_EFFECT_SEGMENT);
+            this.reportOperation('add', incremental, startTime);
         }
         async removeEffects(effects) {
+            // See addEffects — same wall-clock-across-the-method measurement.
+            const startTime = Date.now();
             const incremental = draftQueueSideEffectMapGate.isOpen({ fallback: true });
             const effectKeys = effects.map((e) => e.uniqueId);
             effects.forEach((effect) => {
@@ -93805,6 +94161,7 @@
                 this.regenerateKeyToEffectMap();
             }
             await this.durableStore.evictEntries(effectKeys, SIDE_EFFECT_SEGMENT);
+            this.reportOperation('remove', incremental, startTime);
         }
         getEffects(key) {
             const effects = this.keyToEffectMap.get(key);
@@ -93814,6 +94171,10 @@
             return effects;
         }
         getEffectsByTag(tag) {
+            // This scan is still O(N) over every effect regardless of the incremental-map
+            // gate — timing it tells us whether that residual scan is the quadratic hotspot during churn.
+            const startTime = Date.now();
+            const incremental = draftQueueSideEffectMapGate.isOpen({ fallback: true });
             const filteredEffects = [];
             const { keyToEffectMap } = this;
             // Loop through every entry in the map
@@ -93823,7 +94184,17 @@
                 // Add the matching effects to the filtered list
                 filteredEffects.push(...matchingEffects);
             }
-            return filteredEffects.sort((a, b) => a.timestamp - b.timestamp);
+            const result = filteredEffects.sort((a, b) => a.timestamp - b.timestamp);
+            this.reportOperation('getByTag', incremental, startTime);
+            return result;
+        }
+        reportOperation(op, incremental, startedAt) {
+            try {
+                reportDraftQueueSideEffectOp(op, incremental, Date.now() - startedAt, this.allEffects.size);
+            }
+            catch {
+                // Telemetry must not change side-effect store behavior.
+            }
         }
         async initialize() {
             const effects = await this.durableStore.getAllEntries(SIDE_EFFECT_SEGMENT);
@@ -97020,7 +97391,7 @@
             },
         };
     }
-    // version: 1.454.0-4223ab4365
+    // version: 1.456.0-cef836b978
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -97046,7 +97417,7 @@
             },
         };
     }
-    // version: 1.454.0-4223ab4365
+    // version: 1.456.0-cef836b978
 
     function findExecutableOperation$1(input) {
       const operations = input.query.definitions.filter(
@@ -99755,7 +100126,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$2,
     });
-    // version: 1.454.0-4223ab4365
+    // version: 1.456.0-cef836b978
 
     const { create: create$2, keys: keys$2 } = Object;
     const { stringify, parse } = JSON;
@@ -100219,10 +100590,11 @@
             }
           ]);
         }
+        const existingArrayData = input.existingNormalizedData?.data;
         const arrayNormalizationErrors = [];
         const normalizedArray = [];
         input.data.forEach((item, index) => {
-          const existingItemData = input.existingNormalizedData?.[index];
+          const existingItemData = existingArrayData?.[index];
           const normalizedItemResult = this.items.write(cache, {
             ...input,
             data: item,
@@ -107290,7 +107662,7 @@
             cb(graphql_v1_import, graphql_imperative$1, graphql_imperative_legacy_v1_import, graphql_state_manager, useOneStoreGraphQL);
         }
     }
-    // version: 1.454.0-761808c4e9
+    // version: 1.456.0-6ed480b93c
 
     function createFragmentMap(documentNode) {
         const fragments = {};
@@ -124019,7 +124391,7 @@
         return keyBuilder$z(luvio, keyParams);
     }
 
-    const { assign: assign$1, create: create$1, freeze: freeze$1, isFrozen: isFrozen$1, keys: keys$1 } = Object;
+    const { assign: assign$1, create: create$1, freeze: freeze$1, getPrototypeOf: getPrototypeOf$1, isFrozen: isFrozen$1, keys: keys$1 } = Object;
     const { isArray: isArray$2 } = Array;
     const { concat: concat$1, filter: filter$1, includes: includes$1, push: push$1, reduce: reduce$1 } = Array.prototype;
 
@@ -136533,7 +136905,7 @@
         configuration: { ...configurationForGraphQLAdapters$1 },
         instrument: instrument$1,
     });
-    // version: 1.454.0-761808c4e9
+    // version: 1.456.0-6ed480b93c
 
     // On core the unstable adapters are re-exported with different names,
     // we want to match them here.
@@ -136685,7 +137057,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.454.0-761808c4e9
+    // version: 1.456.0-6ed480b93c
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -137484,7 +137856,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.454.0-4223ab4365
+    // version: 1.456.0-cef836b978
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -137770,7 +138142,7 @@
     }
     const keyPrefix = 'UiApi';
 
-    const { assign, create, freeze, isFrozen, keys } = Object;
+    const { assign, create, freeze, getPrototypeOf, isFrozen, keys } = Object;
     const { isArray } = Array;
     const { concat, filter, includes, push, reduce } = Array.prototype;
 
@@ -138794,4 +139166,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.454.0-4223ab4365
+// version: 1.456.0-cef836b978