@salesforce/lds-worker-api 1.365.0 → 1.366.0

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

@@ -4274,7 +4274,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.365.0-eec7b6223e
+// version: 1.366.0-30380c7ed7
 
 // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
 function instrumentAdapter$1(createFunction, _metadata) {
@@ -4865,7 +4865,7 @@ function safeSanitizeGraphQLConfigObject(config) {
 }
 
 // For use by callers within this module to instrument interesting things.
-let instrumentation$5 = {
+let instrumentation$6 = {
     refreshCalled: (_fromSource) => { },
     instrumentAdapter: (adapter, _metadata) => {
         return adapter;
@@ -4880,20 +4880,20 @@ let instrumentation$5 = {
  * @param newInstrumentation instrumentation hooks to be overridden
  */
 function instrument$4(newInstrumentation) {
-    instrumentation$5 = Object.assign(instrumentation$5, newInstrumentation);
+    instrumentation$6 = Object.assign(instrumentation$6, newInstrumentation);
 }
 
 let refresh$3;
 function bindWireRefresh(luvio) {
     const wireRefresh = bindWireRefresh$1(luvio);
     refresh$3 = (data, apiFamily) => {
-        instrumentation$5.refreshCalled(apiFamily);
+        instrumentation$6.refreshCalled(apiFamily);
         return wireRefresh(data);
     };
 }
 
 function createInstrumentedAdapter(adapter, metadata) {
-    return instrumentation$5.instrumentAdapter(adapter, metadata);
+    return instrumentation$6.instrumentAdapter(adapter, metadata);
 }
 
 function createLDSAdapter(luvio, name, factory) {
@@ -5239,7 +5239,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     const { apiFamily, name } = metadata;
     return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
-// version: 1.365.0-eec7b6223e
+// version: 1.366.0-30380c7ed7
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -5851,7 +5851,7 @@ function ensureRegisteredOnce$2(registration) {
 }
 
 // For use by callers within this module to instrument interesting things.
-let instrumentation$4 = {
+let instrumentation$5 = {
     /**
      * Called when a set of record conflicts has been fully resolved. The
      * parameter indicates the number of server requests that were needed
@@ -5900,7 +5900,7 @@ let instrumentation$4 = {
  * @param newInstrumentation instrumentation hooks to be overridden
  */
 function instrument$3(newInstrumentation) {
-    instrumentation$4 = Object.assign(instrumentation$4, newInstrumentation);
+    instrumentation$5 = Object.assign(instrumentation$5, newInstrumentation);
 }
 
 const engineForPrefetcherMap = new Map();
@@ -9787,7 +9787,7 @@ function merge$3(existing, incoming, luvio, _path, recordConflictMap) {
             incoming.recordTypeId === undefined ||
             existing.recordTypeId === null ||
             existing.recordTypeId === undefined) {
-            instrumentation$4.recordTypeIdIsNull(incoming.apiName);
+            instrumentation$5.recordTypeIdIsNull(incoming.apiName);
         }
         const recordDepKey = dependencyKeyBuilder$1({ recordId: existing.id });
         const node = luvio.getNode(recordDepKey);
@@ -9812,12 +9812,12 @@ function merge$3(existing, incoming, luvio, _path, recordConflictMap) {
     // }
     // Adding instrumentation to see how frequently this occurs
     if (existing.apiName !== incoming.apiName) {
-        instrumentation$4.recordApiNameChanged(incoming.apiName, existing.apiName);
+        instrumentation$5.recordApiNameChanged(incoming.apiName, existing.apiName);
     }
     const incomingWeakEtagZero = incoming.weakEtag === 0;
     const existingWeakEtagZero = existing.weakEtag === 0;
     if (incomingWeakEtagZero || existingWeakEtagZero) {
-        instrumentation$4.weakEtagZero(incomingWeakEtagZero, existingWeakEtagZero, incoming.apiName);
+        instrumentation$5.weakEtagZero(incomingWeakEtagZero, existingWeakEtagZero, incoming.apiName);
     }
     // TODO [W-6900085]: UIAPI returns weakEtag=0 when the record is >2 levels nested. For now
     // we treat the record as mergeable.
@@ -9877,7 +9877,7 @@ function fixDisplayValue(existing, incoming, path) {
         incomingValue !== null) {
         incoming.displayValue = existing.displayValue;
         const isSpanningRecord = typeof incomingValue === 'object';
-        instrumentation$4.nullDisplayValueConflict({
+        instrumentation$5.nullDisplayValueConflict({
             entityName: path.parent.data.apiName,
             fieldName: path.propertyName,
             fieldType: isSpanningRecord ? 'spanning-record' : 'scalar',
@@ -10667,7 +10667,7 @@ function buildNetworkSnapshot$15(luvio, config, serverRequestCount = 0, options)
 function resolveConflict$1(luvio, map) {
     const ids = keys$7(map.conflicts);
     if (ids.length === 0) {
-        instrumentation$4.recordConflictsResolved(map.serverRequestCount);
+        instrumentation$5.recordConflictsResolved(map.serverRequestCount);
         return;
     }
     if (ids.length === 1) {
@@ -15508,7 +15508,7 @@ const notifyChangeFactory = (luvio) => {
                             serverRequestCount: 1,
                         }), body);
                         const result = luvio.storeBroadcast();
-                        instrumentation$4.getRecordNotifyChangeNetworkResult(existingWeakEtag !== body.weakEtag);
+                        instrumentation$5.getRecordNotifyChangeNetworkResult(existingWeakEtag !== body.weakEtag);
                         return result;
                     }, () => {
                         const cache = new StoreKeyMap();
@@ -15520,7 +15520,7 @@ const notifyChangeFactory = (luvio) => {
                         const errorSnapshot = luvio.errorSnapshot(error);
                         luvio.storeIngestError(key, errorSnapshot, RECORD_REPRESENTATION_ERROR_STORE_METADATA_PARAMS$1);
                         const result = luvio.storeBroadcast();
-                        instrumentation$4.getRecordNotifyChangeNetworkResult(null, true);
+                        instrumentation$5.getRecordNotifyChangeNetworkResult(null, true);
                         return result.then(() => errorSnapshot);
                     });
                 });
@@ -34033,12 +34033,12 @@ withDefaultLuvio((luvio) => {
     baseUpdateRelatedListInfo = createLDSAdapter(luvio, 'baseUpdateRelatedListInfo', updateRelatedListInfoAdapterFactory);
     createLDSAdapter(luvio, 'baseUpdateRelatedListPreferences', updateRelatedListPreferencesAdapterFactory);
     throttle(60, 60000, createLDSAdapter(luvio, 'getRecordNotifyChange', notifyChangeFactory), {
-        allowFunction: instrumentation$4.getRecordNotifyChangeAllowed,
-        dropFunction: instrumentation$4.getRecordNotifyChangeDropped,
+        allowFunction: instrumentation$5.getRecordNotifyChangeAllowed,
+        dropFunction: instrumentation$5.getRecordNotifyChangeDropped,
     });
     throttle(60, 60000, createLDSAdapter(luvio, 'notifyRecordUpdateAvailable', notifyUpdateAvailableFactory$5), {
-        allowFunction: instrumentation$4.notifyRecordUpdateAvailableAllowed,
-        dropFunction: instrumentation$4.notifyRecordUpdateAvailableDropped,
+        allowFunction: instrumentation$5.notifyRecordUpdateAvailableAllowed,
+        dropFunction: instrumentation$5.notifyRecordUpdateAvailableDropped,
     });
     throttle(60, 60000, createLDSAdapter(luvio, 'notifyListViewSummaryUpdateAvailable', notifyUpdateAvailableFactory$2));
     throttle(60, 60000, createLDSAdapter(luvio, 'notifyListInfoSummaryUpdateAvailable', notifyUpdateAvailableFactory$3));
@@ -34052,7 +34052,50 @@ withDefaultLuvio((luvio) => {
     throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
     throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
 });
-// version: 1.365.0-4e4411f8a4
+// version: 1.366.0-bf15f04cce
+
+function requestIdleDetectedCallback(_callback) { }
+function declareNotifierTaskSingle(_name) {
+    return {
+        isBusy: false,
+        done: function () { },
+    };
+}
+function declareNotifierTaskMulti(_name, _existingBusyCount) {
+    return {
+        isBusy: false,
+        add: function () { },
+        done: function () { },
+    };
+}
+function declarePollableTaskMulti(_name, _isBusyChecker) { }
+const idleDetector = {
+    requestIdleDetectedCallback,
+    declareNotifierTaskSingle,
+    declareNotifierTaskMulti,
+    declarePollableTaskMulti,
+};
+function stop(_userSchemaOrText, _userData) { }
+function error(_error, _userSchemaOrText, _userData) { }
+const activity = {
+    stop,
+    error,
+};
+function startActivity(_name) {
+    return activity;
+}
+function log(_schema, _data) { }
+const mockInstrumentation = {
+    log,
+    startActivity,
+    error: () => { },
+    trackValue: (_operation, _value, _hasError, _tags) => { },
+    incrementCounter: (_operation, _increment, _hasError, _tags) => { },
+    bucketValue: (_operation, _value, _buckets) => { },
+};
+const getInstrumentation = () => {
+    return mockInstrumentation;
+};
 
 /**
  * Returns true if the value acts like a Promise, i.e. has a "then" function,
@@ -45516,49 +45559,6 @@ var graphqQueryFieldLimit = {
 
 var caseSensitiveUserId = '005B0000000GR4OIAW';
 
-function requestIdleDetectedCallback(_callback) { }
-function declareNotifierTaskSingle(_name) {
-    return {
-        isBusy: false,
-        done: function () { },
-    };
-}
-function declareNotifierTaskMulti(_name, _existingBusyCount) {
-    return {
-        isBusy: false,
-        add: function () { },
-        done: function () { },
-    };
-}
-function declarePollableTaskMulti(_name, _isBusyChecker) { }
-const idleDetector = {
-    requestIdleDetectedCallback,
-    declareNotifierTaskSingle,
-    declareNotifierTaskMulti,
-    declarePollableTaskMulti,
-};
-function stop(_userSchemaOrText, _userData) { }
-function error(_error, _userSchemaOrText, _userData) { }
-const activity = {
-    stop,
-    error,
-};
-function startActivity(_name) {
-    return activity;
-}
-function log(_schema, _data) { }
-const mockInstrumentation = {
-    log,
-    startActivity,
-    error: () => { },
-    trackValue: (_operation, _value, _hasError, _tags) => { },
-    incrementCounter: (_operation, _increment, _hasError, _tags) => { },
-    bucketValue: (_operation, _value, _buckets) => { },
-};
-const getInstrumentation = () => {
-    return mockInstrumentation;
-};
-
 var ldsAdapterO11yLoggingGate = {
     isOpen: function (e) {
         return e.fallback;
@@ -45674,7 +45674,7 @@ const { entries: entries$3, keys: keys$5 } = Object;
 
 const UI_API_BASE_URI = '/services/data/v65.0/ui-api';
 
-let instrumentation$2 = {
+let instrumentation$3 = {
     aggregateUiChunkCount: (_cb) => { },
     aggregateUiConnectError: () => { },
     duplicateRequest: (_cb) => { },
@@ -45686,7 +45686,7 @@ let instrumentation$2 = {
     networkRateLimitExceeded: () => { },
 };
 function instrument$2(newInstrumentation) {
-    instrumentation$2 = Object.assign(instrumentation$2, newInstrumentation);
+    instrumentation$3 = Object.assign(instrumentation$3, newInstrumentation);
 }
 
 const LDS_RECORDS_AGGREGATE_UI = 'LDS_Records_AggregateUi';
@@ -45756,7 +45756,7 @@ function mergeRecordFields$2(first, second) {
  *  would otherwise cause a query length exception.
  */
 function dispatchSplitRecordAggregateUiAction(recordId, networkAdapter, resourceRequest, resourceRequestContext) {
-    instrumentation$2.getRecordAggregateInvoke();
+    instrumentation$3.getRecordAggregateInvoke();
     return networkAdapter(resourceRequest, resourceRequestContext).then((resp) => {
         const { body } = resp;
         // This response body could be an executeAggregateUi, which we don't natively support.
@@ -45772,7 +45772,7 @@ function dispatchSplitRecordAggregateUiAction(recordId, networkAdapter, resource
         }
         const merged = body.compositeResponse.reduce((seed, response) => {
             if (response.httpStatusCode !== HttpStatusCode$1.Ok) {
-                instrumentation$2.getRecordAggregateReject(() => recordId);
+                instrumentation$3.getRecordAggregateReject(() => recordId);
                 throw createErrorResponse(HttpStatusCode$1.ServerError, {
                     error: response.message,
                 });
@@ -45782,7 +45782,7 @@ function dispatchSplitRecordAggregateUiAction(recordId, networkAdapter, resource
             }
             return mergeRecordFields$2(seed, response.body);
         }, null);
-        instrumentation$2.getRecordAggregateResolve(() => {
+        instrumentation$3.getRecordAggregateResolve(() => {
             return {
                 recordId,
                 apiName: merged.apiName,
@@ -45790,7 +45790,7 @@ function dispatchSplitRecordAggregateUiAction(recordId, networkAdapter, resource
         });
         return createOkResponse$1(merged);
     }, (err) => {
-        instrumentation$2.getRecordAggregateReject(() => recordId);
+        instrumentation$3.getRecordAggregateReject(() => recordId);
         // rethrow error
         throw err;
     });
@@ -45868,7 +45868,7 @@ function buildAndDispatchGetRecordAggregateUi(recordId, req, params) {
     const { networkAdapter, resourceRequest, resourceRequestContext } = req;
     const compositeRequest = buildGetRecordByFieldsCompositeRequest(resourceRequest, params);
     // W-12245125: Emit chunk size metrics
-    instrumentation$2.aggregateUiChunkCount(() => compositeRequest.length);
+    instrumentation$3.aggregateUiChunkCount(() => compositeRequest.length);
     const aggregateUiParams = {
         compositeRequest,
     };
@@ -46102,7 +46102,7 @@ function platformNetworkAdapter(baseNetworkAdapter) {
     return (resourceRequest, resourceRequestContext) => {
         if (!tokenBucket.take(1)) {
             // We are hitting rate limiting, add some metrics
-            instrumentation$2.networkRateLimitExceeded();
+            instrumentation$3.networkRateLimitExceeded();
         }
         const salesforceRequest = {
             networkAdapter: baseNetworkAdapter,
@@ -80354,6 +80354,209 @@ class AbstractQuickActionHandler extends AbstractResourceRequestActionHandler {
     }
 }
 
+function attachObserversToAdapterRequestContext(observers, adapterRequestContext) {
+    if (adapterRequestContext === undefined) {
+        return { eventObservers: observers };
+    }
+    if (adapterRequestContext.eventObservers === undefined) {
+        return { ...adapterRequestContext, eventObservers: observers };
+    }
+    return {
+        ...adapterRequestContext,
+        eventObservers: adapterRequestContext.eventObservers.concat(observers),
+    };
+}
+/**
+ * Use this method to sanitize the unknown error object when
+ * we are unsure of the type of the error thrown
+ *
+ * @param err Unknown object to sanitize
+ * @returns an instance of error
+ */
+function normalizeError$1(err) {
+    if (err instanceof Error) {
+        return err;
+    }
+    else if (typeof err === 'string') {
+        return new Error(err);
+    }
+    return new Error(stringify$2(err));
+}
+// metrics
+/** GraphQL */
+const GRAPHQL_EVAL_ERROR = 'gql-eval-error';
+const GRAPHQL_EVAL_DB_READ_DURATION = 'gql-eval-db-read-duration';
+const GRAPHQL_EVAL_ROOT_QUERY_COUNT = 'gql-eval-root-query-count';
+const GRAPHQL_EVAL_TOTAL_QUERY_COUNT = 'gql-eval-total-query-count';
+const GRAPHQL_EVAL_MAX_CHILD_RELATIONSHIPS_COUNT = 'gql-eval-max-child-count';
+const GRAPHQL_EVAL_QUERY_RECORD_COUNT = 'gql-eval-query-record-count';
+const GRAPHQL_SNAPSHOT_REFRESH_UNDEFINED = 'gql-snapshot-refresh-undefined';
+/** Draft Queue */
+const DRAFT_QUEUE_STATE_STARTED = 'draft-queue-state-started';
+const DRAFT_QUEUE_STATE_ERROR = 'draft-queue-state-error';
+const DRAFT_QUEUE_STATE_WAITING = 'draft-queue-state-waiting';
+const DRAFT_QUEUE_STATE_STOPPED = 'draft-queue-state-stopped';
+const DRAFT_QUEUE_ACTION_ADDED = 'draft-queue-action-added';
+const DRAFT_QUEUE_ACTION_UPLOADING = 'draft-queue-action-uploading';
+const DRAFT_QUEUE_ACTION_COMPLETED = 'draft-queue-action-completed';
+const DRAFT_QUEUE_ACTION_DELETED = 'draft-queue-action-deleted';
+const DRAFT_QUEUE_ACTION_UPDATED = 'draft-queue-action-updated';
+const DRAFT_QUEUE_ACTION_FAILED = 'draft-queue-action-failed';
+const DRAFT_QUEUE_TOTAL_MERGE_ACTIONS_CALLS = 'draft-queue-total-mergeActions-calls';
+/** Content Document */
+const CREATE_CONTENT_DOCUMENT_AND_VERSION_TOTAL_SYNTHESIZE_CALLS = 'content-document-version-total-synthesize-calls';
+const CREATE_CONTENT_DOCUMENT_AND_VERSION_DRAFT_SYNTHESIZE_ERROR = 'create-content-document-version-draft-synthesize-error';
+/** Priming */
+const PRIMING_TOTAL_SESSION_COUNT = 'priming-total-session-count';
+const PRIMING_TOTAL_ERROR_COUNT = 'priming-total-error-count';
+const PRIMING_TOTAL_PRIMED_COUNT = 'priming-total-primed-count';
+const PRIMING_TOTAL_CONFLICT_COUNT = 'priming-total-conflict-count';
+// logs
+const GRAPHQL_QUERY_PARSE_ERROR = 'gql-query-parse-error';
+const GRAPHQL_SQL_EVAL_PRECONDITION_ERROR = 'gql-sql-pre-eval-error';
+const GRAPHQL_CREATE_SNAPSHOT_ERROR = 'gql-create-snapshot-error';
+const DRAFT_AWARE_CREATE_CONTENT_DOCUMENT_AND_VERSION_ERROR = 'draft-aware-create-content-document-and-version-error';
+const ldsMobileInstrumentation$2 = getInstrumentation();
+const nimbusLogger = typeof __nimbus !== 'undefined' &&
+    __nimbus.plugins !== undefined &&
+    __nimbus.plugins.JSLoggerPlugin !== undefined
+    ? __nimbus.plugins.JSLoggerPlugin
+    : undefined;
+function reportGraphqlQueryParseError(err) {
+    const error = normalizeError$1(err);
+    const errorCode = GRAPHQL_QUERY_PARSE_ERROR;
+    // Metric
+    reportGraphqlAdapterError(errorCode);
+    // Log
+    ldsMobileInstrumentation$2.error(error, errorCode);
+}
+function reportGraphqlSqlEvalPreconditionError(err) {
+    const error = normalizeError$1(err);
+    const errorCode = GRAPHQL_SQL_EVAL_PRECONDITION_ERROR;
+    // Metric
+    reportGraphqlAdapterError(errorCode);
+    // Log
+    ldsMobileInstrumentation$2.error(error, errorCode);
+}
+function reportGraphqlCreateSnapshotError(err) {
+    const error = normalizeError$1(err);
+    const errorCode = GRAPHQL_CREATE_SNAPSHOT_ERROR;
+    // Metric
+    reportGraphqlAdapterError(errorCode);
+    // Log
+    ldsMobileInstrumentation$2.error(error, errorCode);
+}
+function reportGraphQlEvalDbReadDuration(duration) {
+    ldsMobileInstrumentation$2.trackValue(GRAPHQL_EVAL_DB_READ_DURATION, duration);
+}
+function reportGraphqlAdapterError(errorCode) {
+    // Increment overall count with errorCode as tag
+    ldsMobileInstrumentation$2.incrementCounter(GRAPHQL_EVAL_ERROR, 1, true, { errorCode });
+}
+function reportGraphqlQueryInstrumentation(data) {
+    const queryBuckets = [1, 2, 3, 4, 5, 10, 20, 50, 100];
+    const recordBuckets = [
+        1, 5, 10, 20, 50, 100, 1000, 2000, 5000, 10000, 50000, 100000, 1000000,
+    ];
+    ldsMobileInstrumentation$2.bucketValue(GRAPHQL_EVAL_ROOT_QUERY_COUNT, data.rootQueryCount, queryBuckets);
+    ldsMobileInstrumentation$2.bucketValue(GRAPHQL_EVAL_TOTAL_QUERY_COUNT, data.totalQueryCount, queryBuckets);
+    ldsMobileInstrumentation$2.bucketValue(GRAPHQL_EVAL_MAX_CHILD_RELATIONSHIPS_COUNT, data.maxChildRelationships, queryBuckets);
+    ldsMobileInstrumentation$2.bucketValue(GRAPHQL_EVAL_QUERY_RECORD_COUNT, data.requestedRecordCount, recordBuckets);
+}
+function incrementGraphQLRefreshUndfined() {
+    ldsMobileInstrumentation$2.incrementCounter(GRAPHQL_SNAPSHOT_REFRESH_UNDEFINED);
+}
+function reportDraftActionEvent(state, draftCount, message) {
+    if (nimbusLogger) {
+        nimbusLogger.logInfo(`Draft action event: ${state}, depth: ${draftCount}${message ? `, message: ${message}` : ''}`);
+    }
+    switch (state) {
+        case 'added':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_ADDED);
+            break;
+        case 'uploading':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_UPLOADING);
+            break;
+        case 'completed':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_COMPLETED);
+            break;
+        case 'deleted':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_DELETED);
+            break;
+        case 'failed':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_FAILED, 1, true);
+            break;
+        case 'updated':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_ACTION_UPDATED);
+            break;
+    }
+}
+function reportDraftQueueState(state, draftCount) {
+    if (nimbusLogger) {
+        nimbusLogger.logInfo(`Draft state changed: ${state}, depth: ${draftCount}`);
+    }
+    switch (state) {
+        case 'started':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_STATE_STARTED);
+            break;
+        case 'error':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_STATE_ERROR, 1, true);
+            break;
+        case 'waiting':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_STATE_WAITING);
+            break;
+        case 'stopped':
+            ldsMobileInstrumentation$2.incrementCounter(DRAFT_QUEUE_STATE_STOPPED);
+            break;
+    }
+}
+function reportDraftAwareContentDocumentVersionSynthesizeError(err) {
+    let error;
+    if (err.body !== undefined) {
+        error = err.body;
+    }
+    else {
+        error = normalizeError$1(err);
+    }
+    const errorCode = DRAFT_AWARE_CREATE_CONTENT_DOCUMENT_AND_VERSION_ERROR;
+    const errorType = error.errorType;
+    const tags = {
+        errorCode,
+    };
+    if (errorType !== undefined) {
+        tags.errorType = errorType;
+    }
+    // Metric
+    ldsMobileInstrumentation$2.incrementCounter(CREATE_CONTENT_DOCUMENT_AND_VERSION_DRAFT_SYNTHESIZE_ERROR, 1, true, tags);
+    // Log
+    ldsMobileInstrumentation$2.error(error, errorCode);
+}
+function reportDraftAwareContentVersionSynthesizeCalls(mimeType) {
+    ldsMobileInstrumentation$2.incrementCounter(CREATE_CONTENT_DOCUMENT_AND_VERSION_TOTAL_SYNTHESIZE_CALLS, 1, undefined, { mimeType });
+}
+/** Priming */
+function reportPrimingSessionCreated() {
+    ldsMobileInstrumentation$2.incrementCounter(PRIMING_TOTAL_SESSION_COUNT, 1, undefined, {});
+}
+function reportPrimingError(errorType, recordCount) {
+    ldsMobileInstrumentation$2.incrementCounter(PRIMING_TOTAL_ERROR_COUNT, recordCount, undefined, {
+        errorType,
+    });
+}
+function reportPrimingSuccess(recordCount) {
+    ldsMobileInstrumentation$2.incrementCounter(PRIMING_TOTAL_PRIMED_COUNT, recordCount, undefined);
+}
+function reportPrimingConflict(resolutionType, recordCount) {
+    ldsMobileInstrumentation$2.incrementCounter(PRIMING_TOTAL_CONFLICT_COUNT, recordCount, undefined, {
+        resolutionType,
+    });
+}
+/** Network */
+function reportChunkCandidateUrlLength(urlLength) {
+    const buckets = [8000, 10000, 12000, 14000, 16000];
+    ldsMobileInstrumentation$2.bucketValue('chunk-candidate-url-length-histogram', urlLength, buckets);
+}
+
 const QUICK_ACTION_HANDLER = 'QUICK_ACTION_HANDLER';
 class QuickActionExecutionRepresentationHandler extends AbstractQuickActionHandler {
     constructor(getLuvio, draftRecordService, draftQueue, networkAdapter, isDraftId, sideEffectService, objectInfoService, getRecord) {
@@ -80364,6 +80567,7 @@ class QuickActionExecutionRepresentationHandler extends AbstractQuickActionHandl
         this.objectInfoService = objectInfoService;
         this.getRecord = getRecord;
         this.handlerId = QUICK_ACTION_HANDLER;
+        this.instrumentation = getInstrumentation();
         draftRecordService.registerRecordHandler(this);
     }
     async draftActionToSideEffects(queueEntry) {
@@ -80395,10 +80599,26 @@ class QuickActionExecutionRepresentationHandler extends AbstractQuickActionHandl
         luvio.storeIngest(key, ingest$B$2, response);
     }
     async handleActionCompleted(action, queueOperations) {
+        /* performQuickAction will not return the new record itself, so before the action
+         * is marked as completed, we need to fetch the actual record. This must be done before
+         * the super method is called because the super method will revert the side effects that
+         * were created for this action, and critically that means evicting the synthetic record
+         * that was created to represent the draft of what would become the canonical record.
+         * Since getRecord is a network call, it is better to have a small timeframe (on the order
+         * of microseconds) where both the synthetic record and the canonical record are in the
+         * store instead of the record missing from the store for the entire duration of the
+         * network call.
+         */
+        try {
+            await this.fetchRecordIntoStoreFromCompletedAction(action);
+        }
+        catch (error) {
+            this.instrumentation.error(error, 'Error fetching the record created from performQuickAction adapter.');
+        }
         await super.handleActionCompleted(action, queueOperations);
-        this.getLuvio();
+    }
+    async fetchRecordIntoStoreFromCompletedAction(action) {
         const canonicalId = action.response.body.id;
-        this.buildTagForTargetId(canonicalId);
         const prefix = canonicalId.substring(0, 3);
         if (prefix.length !== 3) {
             // if we can't get a prefix, don't do the rest
@@ -88105,6 +88325,9 @@ function stringifyIfPresent(value) {
     if (value === undefined || value === null) {
         return null;
     }
+    if (typeof value === 'string') {
+        return value;
+    }
     return stringify$1(value);
 }
 function parseIfPresent(value) {
@@ -88810,96 +89033,6 @@ class NimbusDraftQueue {
     }
 }
 
-function attachObserversToAdapterRequestContext(observers, adapterRequestContext) {
-    if (adapterRequestContext === undefined) {
-        return { eventObservers: observers };
-    }
-    if (adapterRequestContext.eventObservers === undefined) {
-        return { ...adapterRequestContext, eventObservers: observers };
-    }
-    return {
-        ...adapterRequestContext,
-        eventObservers: adapterRequestContext.eventObservers.concat(observers),
-    };
-}
-/**
- * Use this method to sanitize the unknown error object when
- * we are unsure of the type of the error thrown
- *
- * @param err Unknown object to sanitize
- * @returns an instance of error
- */
-function normalizeError$1(err) {
-    if (err instanceof Error) {
-        return err;
-    }
-    else if (typeof err === 'string') {
-        return new Error(err);
-    }
-    return new Error(stringify$2(err));
-}
-const GRAPHQL_EVAL_ROOT_QUERY_COUNT = 'gql-eval-root-query-count';
-const GRAPHQL_EVAL_TOTAL_QUERY_COUNT = 'gql-eval-total-query-count';
-const GRAPHQL_EVAL_MAX_CHILD_RELATIONSHIPS_COUNT = 'gql-eval-max-child-count';
-const GRAPHQL_EVAL_QUERY_RECORD_COUNT = 'gql-eval-query-record-count';
-const DRAFT_QUEUE_TOTAL_MERGE_ACTIONS_CALLS = 'draft-queue-total-mergeActions-calls';
-const ldsMobileInstrumentation$2 = getInstrumentation();
-const nimbusLogger = typeof __nimbus !== 'undefined' &&
-    __nimbus.plugins !== undefined &&
-    __nimbus.plugins.JSLoggerPlugin !== undefined
-    ? __nimbus.plugins.JSLoggerPlugin
-    : undefined;
-function reportGraphqlQueryParseError(err) {
-    normalizeError$1(err);
-}
-function reportGraphqlSqlEvalPreconditionError(err) {
-    normalizeError$1(err);
-}
-function reportGraphqlCreateSnapshotError(err) {
-    normalizeError$1(err);
-}
-function reportGraphQlEvalDbReadDuration(duration) {
-}
-function reportGraphqlQueryInstrumentation(data) {
-    const queryBuckets = [1, 2, 3, 4, 5, 10, 20, 50, 100];
-    const recordBuckets = [
-        1, 5, 10, 20, 50, 100, 1000, 2000, 5000, 10000, 50000, 100000, 1000000,
-    ];
-    ldsMobileInstrumentation$2.bucketValue(GRAPHQL_EVAL_ROOT_QUERY_COUNT, data.rootQueryCount, queryBuckets);
-    ldsMobileInstrumentation$2.bucketValue(GRAPHQL_EVAL_TOTAL_QUERY_COUNT, data.totalQueryCount, queryBuckets);
-    ldsMobileInstrumentation$2.bucketValue(GRAPHQL_EVAL_MAX_CHILD_RELATIONSHIPS_COUNT, data.maxChildRelationships, queryBuckets);
-    ldsMobileInstrumentation$2.bucketValue(GRAPHQL_EVAL_QUERY_RECORD_COUNT, data.requestedRecordCount, recordBuckets);
-}
-function reportDraftActionEvent(state, draftCount, message) {
-    if (nimbusLogger) {
-        nimbusLogger.logInfo(`Draft action event: ${state}, depth: ${draftCount}${message ? `, message: ${message}` : ''}`);
-    }
-}
-function reportDraftQueueState(state, draftCount) {
-    if (nimbusLogger) {
-        nimbusLogger.logInfo(`Draft state changed: ${state}, depth: ${draftCount}`);
-    }
-}
-function reportDraftAwareContentDocumentVersionSynthesizeError(err) {
-    let error;
-    if (err.body !== undefined) {
-        error = err.body;
-    }
-    else {
-        error = normalizeError$1(err);
-    }
-    error.errorType;
-}
-function reportDraftAwareContentVersionSynthesizeCalls(mimeType) {
-}
-function reportPrimingError(errorType, recordCount) {
-}
-function reportPrimingConflict(resolutionType, recordCount) {
-}
-/** Network */
-function reportChunkCandidateUrlLength(urlLength) {
-}
-
 /**
  * HOF (high-order-function) that instruments any async operation.  If the operation
  * has an error then the hasError param will be set on the call to o11y.incrementCounter
@@ -88911,13 +89044,19 @@ const withInstrumentation = (operation, config) => {
         return operation();
     }
     const { tags, metricName, logError } = config;
+    let hasError = false;
     return operation()
         .catch((err) => {
+        hasError = true;
         const error = normalizeError$1(err);
         tags['errorMessage'] = error.message;
+        if (logError) {
+            ldsMobileInstrumentation$2.error(error);
+        }
         throw err;
     })
         .finally(() => {
+        ldsMobileInstrumentation$2.incrementCounter(metricName, 1, hasError, tags);
     });
 };
 
@@ -89257,6 +89396,9 @@ function instrumentGraphQLEval(adapter) {
                     case 'graphql-query-instrumentation':
                         reportGraphqlQueryInstrumentation(data.data);
                         break;
+                    case 'graphql-luvio-refresh-undefined':
+                        incrementGraphQLRefreshUndfined();
+                        break;
                 }
             }
         },
@@ -89569,6 +89711,9 @@ class LdsInternalDataTable {
 }
 
 const tasker = idleDetector.declareNotifierTaskMulti('NimbusSqliteStore');
+const instrumentation$2 = getInstrumentation();
+const GRAPHQL_QUERY_ROOT_KEY = 'UiApi::uiapi::Query[uiapi]__uiapi__query';
+const GRAPHQL_QUERY_ROOT_METRIC_NAME = 'gql-query-root-object-size';
 class NimbusSqliteStore {
     constructor(plugin, additionalTableMap = {}) {
         this.plugin = plugin;
@@ -89615,6 +89760,9 @@ class NimbusSqliteStore {
         }
         const table = this.getTable(segment);
         const upsertOperation = table.entriesToUpsertOperations(entries, segment);
+        if (entries[GRAPHQL_QUERY_ROOT_KEY]) {
+            this.trackGraphQLQueryRootSize(upsertOperation);
+        }
         return this.batchOperationAsPromise([upsertOperation]);
     }
     setMetadata(entries, segment) {
@@ -89630,7 +89778,11 @@ class NimbusSqliteStore {
             if (cur.type === 'setEntries') {
                 if (keys$6(cur.entries).length > 0) {
                     const table = this.getTable(cur.segment);
-                    acc.push(table.entriesToUpsertOperations(cur.entries, cur.segment));
+                    const upsertOperation = table.entriesToUpsertOperations(cur.entries, cur.segment);
+                    if (cur.entries[GRAPHQL_QUERY_ROOT_KEY]) {
+                        this.trackGraphQLQueryRootSize(upsertOperation);
+                    }
+                    acc.push(upsertOperation);
                 }
             }
             else if (cur.type === 'setMetadata') {
@@ -89714,6 +89866,19 @@ class NimbusSqliteStore {
             });
         }).finally(() => tasker.done());
     }
+    trackGraphQLQueryRootSize(upsertOperation) {
+        try {
+            if (upsertOperation.type !== 'upsert') {
+                return;
+            }
+            const row = upsertOperation.rows.find((r) => r[0] === GRAPHQL_QUERY_ROOT_KEY);
+            if (!(row && row[1] && typeof row[1] === 'string')) {
+                return;
+            }
+            instrumentation$2.trackValue(GRAPHQL_QUERY_ROOT_METRIC_NAME, row[1].length);
+        }
+        catch { }
+    }
 }
 
 // These const values must be in sync with the latest
@@ -90351,6 +90516,7 @@ const SESSION_ENQUEUE_RECORD_COUNT = 'priming-session-enqueue-record-count';
 const SESSION_INGEST_WRITTEN = 'priming-session-ingest-written-count';
 const SESSION_INGEST_CONFLICTED = 'priming-session-ingest-conflicted-count';
 const SESSION_INGEST_ERRORS = 'priming-session-ingest-error-count';
+const SESSION_INGEST_DURATION = 'priming-session-ingest-duration';
 class PrimingSession extends EventEmitter {
     constructor(config) {
         super();
@@ -90525,6 +90691,7 @@ class PrimingSession extends EventEmitter {
         instrumentation$1$1.trackValue(SESSION_INGEST_WRITTEN, written.length);
         instrumentation$1$1.trackValue(SESSION_INGEST_CONFLICTED, conflicted.length);
         instrumentation$1$1.trackValue(SESSION_INGEST_ERRORS, errors.length);
+        instrumentation$1$1.trackValue(SESSION_INGEST_DURATION, Date.now() - beforeWrite);
         stats.conflictedCount = conflicted.length;
         this.emit('batch-written', {
             written,
@@ -91266,10 +91433,12 @@ class RecordLoaderSOQLComposite extends NetworkRecordLoader {
 }
 
 function instrumentPrimingSession(session) {
+    reportPrimingSessionCreated();
     session.on('error', ({ code, ids }) => {
         reportPrimingError(code, ids.length);
     });
     session.on('primed', ({ length }) => {
+        reportPrimingSuccess(length);
     });
     session.on('conflict', ({ ids, resolution }) => {
         reportPrimingConflict(resolution, ids.length);
@@ -92893,7 +93062,7 @@ function isStoreRecordError(storeRecord) {
     return storeRecord.__type === 'error';
 }
 
-const instrumentation$3 = getInstrumentation();
+const instrumentation$4 = getInstrumentation();
 const ProductConsumed = {
     API_NAME: 'ProductConsumed',
     Fields: {
@@ -92951,6 +93120,7 @@ class ProductConsumedUpdatedHook {
         const originalRecord = await this.durableRecordStore.getRecord(buildRecordRepKeyFromId$1(draftRecordId));
         if (originalRecord === undefined) {
             incrementCounter(ProductConsumedUpdatedHook.COUNTER_NAME, CounterResult.Error);
+            instrumentation$4.error(`SFS - ProductConsumedUpdatedHook - Original record ${draftRecordId} not found`);
             return [];
         }
         const originalProductItemId = getProductItemIdFromRecordFields(originalRecord.fields);
@@ -92961,6 +93131,7 @@ class ProductConsumedUpdatedHook {
         }
         if (originalQuantityConsumed === undefined) {
             incrementCounter(ProductConsumedUpdatedHook.COUNTER_NAME, CounterResult.Error);
+            instrumentation$4.error(`SFS - ProductConsumedUpdatedHook - Original record ${draftRecordId} QuantityConsumed not found`);
             return [];
         }
         incrementCounter(ProductConsumedUpdatedHook.COUNTER_NAME, CounterResult.Created);
@@ -92987,6 +93158,7 @@ class ProductConsumedDeletedHook {
         const originalRecord = await this.durableRecordStore.getRecord(buildRecordRepKeyFromId$1(draftRecordId));
         if (originalRecord === undefined) {
             incrementCounter(ProductConsumedDeletedHook.COUNTER_NAME, CounterResult.Error);
+            instrumentation$4.error(`SFS - ProductConsumedDeletedHook - Original record ${draftRecordId} not found`);
             return [];
         }
         const productItemId = getProductItemIdFromRecordFields(originalRecord.fields);
@@ -92997,6 +93169,7 @@ class ProductConsumedDeletedHook {
         }
         if (quantityConsumed === undefined) {
             incrementCounter(ProductConsumedDeletedHook.COUNTER_NAME, CounterResult.Error);
+            instrumentation$4.error(`SFS - ProductConsumedDeletedHook - Original record ${draftRecordId} QuantityConsumed not found`);
             return [];
         }
         incrementCounter(ProductConsumedDeletedHook.COUNTER_NAME, CounterResult.Created);
@@ -93051,7 +93224,7 @@ var CounterResult;
     CounterResult["Error"] = "Error";
 })(CounterResult || (CounterResult = {}));
 function incrementCounter(name, result) {
-    instrumentation$3.incrementCounter('SFSSideEffect', 1, result == CounterResult.Error, {
+    instrumentation$4.incrementCounter('SFSSideEffect', 1, result == CounterResult.Error, {
         Name: name,
         Result: result,
     });
@@ -93256,7 +93429,7 @@ register$1({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$2,
 });
-// version: 1.365.0-eec7b6223e
+// version: 1.366.0-30380c7ed7
 
 const { create: create$2, keys: keys$2 } = Object;
 const { stringify, parse } = JSON;
@@ -119425,7 +119598,7 @@ register$1({
     configuration: { ...configurationForGraphQLAdapters$1 },
     instrument: instrument$1,
 });
-// version: 1.365.0-4e4411f8a4
+// version: 1.366.0-bf15f04cce
 
 // On core the unstable adapters are re-exported with different names,
 // we want to match them here.
@@ -119577,7 +119750,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.365.0-4e4411f8a4
+// version: 1.366.0-bf15f04cce
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -120376,7 +120549,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.365.0-eec7b6223e
+// version: 1.366.0-30380c7ed7
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -121545,4 +121718,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, evictExpiredCacheEntries, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, importLuvioAdapterModule, invokeAdapter, invokeAdapterWithDraftToMerge, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, stopEviction, subscribeToAdapter };
-// version: 1.365.0-eec7b6223e
+// version: 1.366.0-30380c7ed7