@salesforce/lds-runtime-mobile 1.453.0 → 1.455.0

package/sfdc/types/drafts/AbstractResourceRequestActionHandler.d.ts

@@ -88,5 +88,7 @@ export declare abstract class AbstractResourceRequestActionHandler<ResponseType>
      * Overlay the sourceBody over top of the targetBody
      */
     abstract mergeRequestBody<T = unknown>(targetBody: T, sourceBody: T): T;
+    private reportNetworkDuration;
+    private reportRetryAttempt;
 }
 export declare function isResourceRequestAction(action: DraftAction<unknown, unknown>): action is DraftAction<ResourceRequest, unknown>;

package/sfdc/types/drafts/UiApiDraftRecordService.d.ts

@@ -5,6 +5,7 @@ import type { RecordEffectingHandler } from './records/actionHandlers/RecordEffe
 import { type DurableStore } from '@luvio/environments';
 import type { SideEffectStore } from './sideEffects';
 import type { DurableRecordStore } from 'src/durableStore/DurableRecordStore';
+import { type DraftQueueSideEffectLifecycle } from '../instrumentation/metrics';
 export interface ReferenceIdFieldInfo {
     id: string;
     field: FieldRepresentation;
@@ -19,9 +20,10 @@ export declare class UiApiDraftRecordService {
     private recordEffectingHandlers;
     constructor(getLuvio: () => Luvio, durableStore: DurableStore, objectInfoService: ObjectInfoService, generateId: (prefix: string) => string, sideEffectStore: SideEffectStore, durableRecordStore: DurableRecordStore);
     registerRecordHandler(recordHandler: RecordEffectingHandler): void;
-    setSideEffectsForActions(changedActions: DraftAction<unknown, unknown>[]): Promise<Set<string>>;
+    setSideEffectsForActions(changedActions: DraftAction<unknown, unknown>[], lifecycle: DraftQueueSideEffectLifecycle): Promise<Set<string>>;
     removeSideEffectsForAction(removedAction: DraftAction<unknown, unknown>): Promise<Set<string>>;
-    reapplyRecordSideEffects(recordKeys: Set<string>): Promise<void>;
+    reapplyRecordSideEffects(recordKeys: Set<string>, lifecycle: DraftQueueSideEffectLifecycle): Promise<void>;
+    private reportSideEffectRegionDuration;
     synthesizeId(apiName: string): Promise<string>;
     checkDraftPrequisites(apiName: string, fields: Record<string, any>): Promise<{
         ok: boolean;

package/sfdc/types/drafts/sideEffects/SideEffectStore.d.ts

@@ -9,6 +9,7 @@ export declare class SideEffectStore {
     removeEffects(effects: SideEffect[]): Promise<void>;
     getEffects(key: string): SideEffect[];
     getEffectsByTag(tag: string): SideEffect[];
+    private reportOperation;
     private initialize;
     private addEffectToKeyMap;
     private removeEffectFromKeyMap;

package/sfdc/types/instrumentation/metrics.d.ts

@@ -24,6 +24,59 @@ export declare function reportDraftQueueNotifyChangedListeners(eventType: string
  * client-CPU-vs-durable split of per-action processing time.
  */
 export declare function reportDraftQueueDurableOperation(op: string, segment: string, durationMs: number): void;
+/**
+ * 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.
+ */
+export declare function reportDraftQueueWorkerTiming(waitMs: number, holdMs: number, queueDepth: number): void;
+/**
+ * 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.
+ */
+export declare function reportDraftQueueActionQueueWait(handlerId: string, waitMs: number): void;
+/**
+ * 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.
+ */
+export declare function reportDraftQueueActionDrainDuration(handlerId: string, durationMs: number): void;
+/**
+ * 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.
+ */
+export declare function reportDraftQueueDrainCycle(durationMs: number, batchSize: number): void;
+/**
+ * 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.
+ */
+export declare function reportDraftQueueActionNetworkDuration(handlerId: string, method: string, statusBucket: string, durationMs: number): void;
+/**
+ * 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.
+ */
+export declare function reportDraftQueueActionRetryAttempt(handlerId: string, cappedOut: boolean): void;
+/**
+ * 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.
+ */
+export declare function reportDraftQueueSideEffectOp(op: string, incremental: boolean, durationMs: number, mapSize: number): void;
+export type DraftQueueSideEffectRegion = 'set' | 'reapply';
+export type DraftQueueSideEffectLifecycle = 'enqueued' | 'removed' | 'replaced-remove' | 'replaced-set' | 'completed-replay' | 'quick-action-completed';
+/**
+ * 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.
+ */
+export declare function reportDraftQueueSideEffectRegionDuration(region: DraftQueueSideEffectRegion, lifecycle: DraftQueueSideEffectLifecycle, durationMs: number): void;
 /**
  * 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
@@ -38,7 +91,7 @@ export declare function reportDraftQueueDurableOperation(op: string, segment: st
  * the action's targetId/tag or any request body/field values.
  */
 export declare function reportDraftActionUploadError(error: unknown, handlerId: string, attempt: number): void;
-export type IdempotencyKeyRotationReason = 'idempotency-error' | 'backdating-collision' | 'merge-actions' | 'generic-400-killswitch';
+export type IdempotencyKeyRotationReason = 'idempotency-error' | 'backdating-collision' | 'merge-actions' | 'server-validation-400' | 'generic-400-killswitch';
 /**
  * Emits a single greppable Splunk log line (and an o11y counter) every time a draft's
  * Idempotency-Key is rotated — i.e. replaced with a fresh uuid rather than reused on