@salesforce/lds-worker-api 1.453.0 → 1.455.0

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

@@ -4148,7 +4148,7 @@ function createResourceParamsImpl(config, configMetadata) {
     }
     return resourceParams;
 }
-// engine version: 0.161.0-fe06f180
+// engine version: 0.161.2-bd1bd38a
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -4276,7 +4276,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.453.0-725e09cf25
+// version: 1.455.0-c53c97de2a
 
 // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
 function instrumentAdapter$1(createFunction, _metadata) {
@@ -5320,7 +5320,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     const { apiFamily, name } = metadata;
     return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
-// version: 1.453.0-725e09cf25
+// version: 1.455.0-c53c97de2a
 
 function isSupportedEntity(_objectApiName) {
     return true;
@@ -5426,11 +5426,11 @@ var TypeCheckShapes;
     TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
     TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
 })(TypeCheckShapes || (TypeCheckShapes = {}));
-// engine version: 0.161.0-fe06f180
+// engine version: 0.161.2-bd1bd38a
 
 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.
@@ -6065,7 +6065,7 @@ function buildAdapterValidationConfig$3(displayName, paramsMeta) {
 }
 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;
@@ -32547,7 +32547,7 @@ withDefaultLuvio((luvio) => {
     throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
     throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
 });
-// version: 1.453.0-e6dc0c039a
+// version: 1.455.0-96e9b41a18
 
 var draftQueueMaxRetryAttemptsGate = {
     isOpen: function (e) {
@@ -47849,16 +47849,18 @@ class LdsAbortController {
 }
 
 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();
         });
@@ -47901,10 +47903,30 @@ class AsyncWorkerPool {
                 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();
+                    }
                 });
             }
         }
@@ -48234,6 +48256,25 @@ const DRAFT_SEGMENT = 'DRAFT';
  */
 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) {
@@ -48256,9 +48297,19 @@ class DurableDraftQueue {
             ? __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;
@@ -48346,6 +48397,9 @@ class DurableDraftQueue {
             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() {
@@ -48376,7 +48430,7 @@ class DurableDraftQueue {
             }
             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) {
@@ -48420,6 +48474,13 @@ class DurableDraftQueue {
                 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,
@@ -48431,6 +48492,16 @@ class DurableDraftQueue {
             },
         });
     }
+    // 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({
@@ -48440,14 +48511,24 @@ class DurableDraftQueue {
         }
         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);
@@ -48467,12 +48548,22 @@ class DurableDraftQueue {
                 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,
@@ -48490,6 +48581,31 @@ class DurableDraftQueue {
         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 },
@@ -48527,7 +48643,7 @@ class DurableDraftQueue {
             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);
     }
     /**
@@ -48556,9 +48672,17 @@ class DurableDraftQueue {
         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({
@@ -80190,6 +80314,20 @@ const DRAFT_QUEUE_GET_QUEUE_ACTIONS_DURATION = 'draft-queue-get-queue-actions-du
 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';
@@ -80309,6 +80447,134 @@ function reportDraftQueueDurableOperation(op, segment, durationMs) {
     });
     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
@@ -80516,8 +80782,16 @@ class AbstractResourceRequestActionHandler {
         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,
@@ -80603,19 +80877,32 @@ class AbstractResourceRequestActionHandler {
                     actionDataChanged = true;
                 }
                 else if (!this.isServerGeneratedError(response.body)) {
-                    // Killswitch CLOSED (default) — only an edge/gateway-injected 400 (no
+                    // Killswitch CLOSED (default) — an edge/gateway-injected 400 (no
                     // recognizable server error body) is retried with the SAME key, so the
                     // server can dedupe a write that may already have committed at the origin.
-                    // A real, server-generated 400 (UiApiError[] or an enhancedErrorType body,
-                    // e.g. a field-validation failure) falls through to the error path below:
-                    // retrying it unchanged would only be rejected again, so the draft is
-                    // errored for the user to fix or discard — the same terminal outcome as
-                    // before this fix, minus the duplicating key rotation. The key is only ever
-                    // rotated by the recognized idempotency error codes above, by a backdating
-                    // collision (new body), or when the user edits an errored draft
-                    // (mergeActions/handleReplaceAction).
+                    // Rotating here is what duplicated the WOLI records (@W-23445154), so the
+                    // key is preserved.
                     shouldRetry = true;
                 }
+                else {
+                    // Killswitch CLOSED — a REAL, server-generated 400 (UiApiError[] or an
+                    // enhancedErrorType body, e.g. a field-validation failure). The origin
+                    // understood the request and rejected it, so it definitively did NOT
+                    // commit — there is no already-written record to duplicate, which is what
+                    // makes rotation safe here (unlike the edge-injected case above).
+                    //
+                    // We still do NOT retry (shouldRetry stays false): the request as-is would
+                    // just be rejected again and wedge the queue. The draft errors for the user
+                    // to fix or discard. But we DO rotate the key: the server's idempotency
+                    // layer caches the 400 against the key, so if the same request is later
+                    // resubmitted unchanged after the server-side validation rule changes to
+                    // allow it, reusing the key would replay that cached 400 and the now-valid
+                    // write would never be applied. Rotating gives the retried request a fresh
+                    // key so the origin re-evaluates it. @W-23445154
+                    updatedAction.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
+                    reportIdempotencyKeyRotated(updatedAction.targetId, 'server-validation-400');
+                    actionDataChanged = true;
+                }
             }
             if (response.status === HttpStatusCode$2.BadRequest &&
                 this.isBackdatingError(response.body, action)) {
@@ -80660,6 +80947,11 @@ class AbstractResourceRequestActionHandler {
             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;
         }
@@ -80695,12 +80987,17 @@ class AbstractResourceRequestActionHandler {
      */
     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),
@@ -80708,6 +81005,7 @@ class AbstractResourceRequestActionHandler {
             }, 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.
@@ -80721,12 +81019,12 @@ class AbstractResourceRequestActionHandler {
         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
@@ -80734,10 +81032,10 @@ class AbstractResourceRequestActionHandler {
         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;
@@ -80771,8 +81069,8 @@ class AbstractResourceRequestActionHandler {
                 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 = [];
@@ -81098,6 +81396,39 @@ class AbstractResourceRequestActionHandler {
             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);
@@ -81461,10 +81792,16 @@ class UiApiDraftRecordService {
     }
     // 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
@@ -81475,31 +81812,45 @@ class UiApiDraftRecordService {
     }
     // 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);
@@ -81735,7 +82086,7 @@ class UpdateRecordQuickActionExecutionRepresentationHandler extends AbstractQuic
         // 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]);
     }
@@ -90415,6 +90766,18 @@ const draftQueueInstrumentation = {
     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
@@ -93757,6 +94120,9 @@ class SideEffectStore {
         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) => {
@@ -93771,8 +94137,11 @@ class SideEffectStore {
             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) => {
@@ -93786,6 +94155,7 @@ class SideEffectStore {
             this.regenerateKeyToEffectMap();
         }
         await this.durableStore.evictEntries(effectKeys, SIDE_EFFECT_SEGMENT);
+        this.reportOperation('remove', incremental, startTime);
     }
     getEffects(key) {
         const effects = this.keyToEffectMap.get(key);
@@ -93795,6 +94165,10 @@ class SideEffectStore {
         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
@@ -93804,7 +94178,17 @@ class SideEffectStore {
             // 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);
@@ -97001,7 +97385,7 @@ function buildServiceDescriptor$b(luvio) {
         },
     };
 }
-// version: 1.453.0-725e09cf25
+// version: 1.455.0-c53c97de2a
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -97027,7 +97411,7 @@ function buildServiceDescriptor$a(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.453.0-725e09cf25
+// version: 1.455.0-c53c97de2a
 
 function findExecutableOperation$1(input) {
   const operations = input.query.definitions.filter(
@@ -99736,7 +100120,7 @@ register$1({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$2,
 });
-// version: 1.453.0-725e09cf25
+// version: 1.455.0-c53c97de2a
 
 const { create: create$2, keys: keys$2 } = Object;
 const { stringify, parse } = JSON;
@@ -107271,7 +107655,7 @@ function registerCallback(cb) {
         cb(graphql_v1_import, graphql_imperative$1, graphql_imperative_legacy_v1_import, graphql_state_manager, useOneStoreGraphQL);
     }
 }
-// version: 1.453.0-e6dc0c039a
+// version: 1.455.0-96e9b41a18
 
 function createFragmentMap(documentNode) {
     const fragments = {};
@@ -124000,7 +124384,7 @@ function keyBuilderFromType(luvio, object) {
     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;
 
@@ -136514,7 +136898,7 @@ register$1({
     configuration: { ...configurationForGraphQLAdapters$1 },
     instrument: instrument$1,
 });
-// version: 1.453.0-e6dc0c039a
+// version: 1.455.0-96e9b41a18
 
 // On core the unstable adapters are re-exported with different names,
 // we want to match them here.
@@ -136666,7 +137050,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.453.0-e6dc0c039a
+// version: 1.455.0-96e9b41a18
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -137465,7 +137849,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.453.0-725e09cf25
+// version: 1.455.0-c53c97de2a
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -137751,7 +138135,7 @@ function buildAdapterValidationConfig(displayName, paramsMeta) {
 }
 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;
 
@@ -138754,4 +139138,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, evictExpiredCacheEntries, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, importLuvioAdapterModule, importOneStoreAdapterModule, invokeAdapter, invokeAdapterWithDraftToMerge, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, stopEviction, subscribeToAdapter };
-// version: 1.453.0-725e09cf25
+// version: 1.455.0-c53c97de2a