@salesforce/lds-worker-api 1.351.1 → 1.353.0

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

@@ -4266,7 +4266,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.351.1-fe0298cc85
+// version: 1.353.0-cc9b469dc4
 
 // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
 function instrumentAdapter$1(createFunction, _metadata) {
@@ -4840,7 +4840,7 @@ function safeSanitizeGraphQLConfigObject(config) {
 }
 
 // For use by callers within this module to instrument interesting things.
-let instrumentation$4 = {
+let instrumentation$5 = {
     refreshCalled: (_fromSource) => { },
     instrumentAdapter: (adapter, _metadata) => {
         return adapter;
@@ -4855,20 +4855,20 @@ let instrumentation$4 = {
  * @param newInstrumentation instrumentation hooks to be overridden
  */
 function instrument$4(newInstrumentation) {
-    instrumentation$4 = Object.assign(instrumentation$4, newInstrumentation);
+    instrumentation$5 = Object.assign(instrumentation$5, newInstrumentation);
 }
 
 let refresh$3;
 function bindWireRefresh(luvio) {
     const wireRefresh = bindWireRefresh$1(luvio);
     refresh$3 = (data, apiFamily) => {
-        instrumentation$4.refreshCalled(apiFamily);
+        instrumentation$5.refreshCalled(apiFamily);
         return wireRefresh(data);
     };
 }
 
 function createInstrumentedAdapter(adapter, metadata) {
-    return instrumentation$4.instrumentAdapter(adapter, metadata);
+    return instrumentation$5.instrumentAdapter(adapter, metadata);
 }
 
 function createLDSAdapter(luvio, name, factory) {
@@ -5214,7 +5214,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     const { apiFamily, name } = metadata;
     return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
-// version: 1.351.1-fe0298cc85
+// version: 1.353.0-cc9b469dc4
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -5826,7 +5826,7 @@ function ensureRegisteredOnce$2(registration) {
 }
 
 // For use by callers within this module to instrument interesting things.
-let instrumentation$3 = {
+let instrumentation$4 = {
     /**
      * Called when a set of record conflicts has been fully resolved. The
      * parameter indicates the number of server requests that were needed
@@ -5875,7 +5875,7 @@ let instrumentation$3 = {
  * @param newInstrumentation instrumentation hooks to be overridden
  */
 function instrument$3(newInstrumentation) {
-    instrumentation$3 = Object.assign(instrumentation$3, newInstrumentation);
+    instrumentation$4 = Object.assign(instrumentation$4, newInstrumentation);
 }
 
 const engineForPrefetcherMap = new Map();
@@ -9733,7 +9733,7 @@ function merge$3(existing, incoming, luvio, _path, recordConflictMap) {
             incoming.recordTypeId === undefined ||
             existing.recordTypeId === null ||
             existing.recordTypeId === undefined) {
-            instrumentation$3.recordTypeIdIsNull(incoming.apiName);
+            instrumentation$4.recordTypeIdIsNull(incoming.apiName);
         }
         const recordDepKey = dependencyKeyBuilder$1({ recordId: existing.id });
         const node = luvio.getNode(recordDepKey);
@@ -9758,12 +9758,12 @@ function merge$3(existing, incoming, luvio, _path, recordConflictMap) {
     // }
     // Adding instrumentation to see how frequently this occurs
     if (existing.apiName !== incoming.apiName) {
-        instrumentation$3.recordApiNameChanged(incoming.apiName, existing.apiName);
+        instrumentation$4.recordApiNameChanged(incoming.apiName, existing.apiName);
     }
     const incomingWeakEtagZero = incoming.weakEtag === 0;
     const existingWeakEtagZero = existing.weakEtag === 0;
     if (incomingWeakEtagZero || existingWeakEtagZero) {
-        instrumentation$3.weakEtagZero(incomingWeakEtagZero, existingWeakEtagZero, incoming.apiName);
+        instrumentation$4.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.
@@ -9823,7 +9823,7 @@ function fixDisplayValue(existing, incoming, path) {
         incomingValue !== null) {
         incoming.displayValue = existing.displayValue;
         const isSpanningRecord = typeof incomingValue === 'object';
-        instrumentation$3.nullDisplayValueConflict({
+        instrumentation$4.nullDisplayValueConflict({
             entityName: path.parent.data.apiName,
             fieldName: path.propertyName,
             fieldType: isSpanningRecord ? 'spanning-record' : 'scalar',
@@ -10613,7 +10613,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$3.recordConflictsResolved(map.serverRequestCount);
+        instrumentation$4.recordConflictsResolved(map.serverRequestCount);
         return;
     }
     if (ids.length === 1) {
@@ -15446,7 +15446,7 @@ const notifyChangeFactory = (luvio) => {
                             serverRequestCount: 1,
                         }), body);
                         const result = luvio.storeBroadcast();
-                        instrumentation$3.getRecordNotifyChangeNetworkResult(existingWeakEtag !== body.weakEtag);
+                        instrumentation$4.getRecordNotifyChangeNetworkResult(existingWeakEtag !== body.weakEtag);
                         return result;
                     }, () => {
                         const cache = new StoreKeyMap();
@@ -15458,7 +15458,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$3.getRecordNotifyChangeNetworkResult(null, true);
+                        instrumentation$4.getRecordNotifyChangeNetworkResult(null, true);
                         return result.then(() => errorSnapshot);
                     });
                 });
@@ -30077,7 +30077,7 @@ function createResourceRequest$e$1(config) {
         method: 'post',
         body: config.body,
         urlParams: {},
-        queryParams: {},
+        queryParams: config.queryParams,
         headers,
         priority: 'normal',
     };
@@ -30086,7 +30086,8 @@ function createResourceRequest$e$1(config) {
 const adapterName$7$1 = 'executeBatchRecordOperations';
 const executeBatchRecordOperations_ConfigPropertyMetadata = [
     generateParamConfigMetadata$3('allOrNone', true, 2, 1, false),
-    generateParamConfigMetadata$3('operations', true, 2, 4, true), // Required, BodyParam, Unsupported(Object type), array
+    generateParamConfigMetadata$3('operations', true, 2, 4, true),
+    generateParamConfigMetadata$3('useDefaultRule', false, 1, 1, false), // Not Requred, QueryParam, Boolean, single
 ];
 const executeBatchRecordOperations_ConfigPropertyNames = 
 /*#__PURE__*/ buildAdapterValidationConfig$3(adapterName$7$1, executeBatchRecordOperations_ConfigPropertyMetadata);
@@ -30122,6 +30123,11 @@ function batchUpdateRecordsTypeCheckConfig(untrustedConfig) {
     if (untrustedConfigAllOrNone !== undefined && typeof untrustedConfigAllOrNone === 'boolean') {
         config.allOrNone = untrustedConfigAllOrNone;
     }
+    const untrustedConfiguseDefaultRule = untrustedConfig.useDefaultRule;
+    if (untrustedConfiguseDefaultRule !== undefined &&
+        typeof untrustedConfiguseDefaultRule === 'boolean') {
+        config.useDefaultRule = untrustedConfiguseDefaultRule;
+    }
     return config;
 }
 function validateAdapterConfig$a$1(untrustedConfig, configPropertyNames) {
@@ -33965,12 +33971,12 @@ withDefaultLuvio((luvio) => {
     baseUpdateRelatedListInfo = createLDSAdapter(luvio, 'baseUpdateRelatedListInfo', updateRelatedListInfoAdapterFactory);
     createLDSAdapter(luvio, 'baseUpdateRelatedListPreferences', updateRelatedListPreferencesAdapterFactory);
     throttle(60, 60000, createLDSAdapter(luvio, 'getRecordNotifyChange', notifyChangeFactory), {
-        allowFunction: instrumentation$3.getRecordNotifyChangeAllowed,
-        dropFunction: instrumentation$3.getRecordNotifyChangeDropped,
+        allowFunction: instrumentation$4.getRecordNotifyChangeAllowed,
+        dropFunction: instrumentation$4.getRecordNotifyChangeDropped,
     });
     throttle(60, 60000, createLDSAdapter(luvio, 'notifyRecordUpdateAvailable', notifyUpdateAvailableFactory$5), {
-        allowFunction: instrumentation$3.notifyRecordUpdateAvailableAllowed,
-        dropFunction: instrumentation$3.notifyRecordUpdateAvailableDropped,
+        allowFunction: instrumentation$4.notifyRecordUpdateAvailableAllowed,
+        dropFunction: instrumentation$4.notifyRecordUpdateAvailableDropped,
     });
     throttle(60, 60000, createLDSAdapter(luvio, 'notifyListViewSummaryUpdateAvailable', notifyUpdateAvailableFactory$2));
     throttle(60, 60000, createLDSAdapter(luvio, 'notifyListInfoSummaryUpdateAvailable', notifyUpdateAvailableFactory$3));
@@ -33984,7 +33990,7 @@ withDefaultLuvio((luvio) => {
     throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
     throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
 });
-// version: 1.351.1-3c191568b9
+// version: 1.353.0-330d59cfcb
 
 /**
  * Returns true if the value acts like a Promise, i.e. has a "then" function,
@@ -45478,7 +45484,9 @@ const activity = {
 function startActivity(_name) {
     return activity;
 }
+function log(_schema, _data) { }
 const mockInstrumentation = {
+    log,
     startActivity,
     error: () => { },
     trackValue: (_operation, _value, _hasError, _tags) => { },
@@ -45604,7 +45612,7 @@ const { entries: entries$3, keys: keys$5 } = Object;
 
 const UI_API_BASE_URI = '/services/data/v64.0/ui-api';
 
-let instrumentation$1$1 = {
+let instrumentation$2 = {
     aggregateUiChunkCount: (_cb) => { },
     aggregateUiConnectError: () => { },
     duplicateRequest: (_cb) => { },
@@ -45616,7 +45624,7 @@ let instrumentation$1$1 = {
     networkRateLimitExceeded: () => { },
 };
 function instrument$2(newInstrumentation) {
-    instrumentation$1$1 = Object.assign(instrumentation$1$1, newInstrumentation);
+    instrumentation$2 = Object.assign(instrumentation$2, newInstrumentation);
 }
 
 const LDS_RECORDS_AGGREGATE_UI = 'LDS_Records_AggregateUi';
@@ -45686,7 +45694,7 @@ function mergeRecordFields$2(first, second) {
  *  would otherwise cause a query length exception.
  */
 function dispatchSplitRecordAggregateUiAction(recordId, networkAdapter, resourceRequest, resourceRequestContext) {
-    instrumentation$1$1.getRecordAggregateInvoke();
+    instrumentation$2.getRecordAggregateInvoke();
     return networkAdapter(resourceRequest, resourceRequestContext).then((resp) => {
         const { body } = resp;
         // This response body could be an executeAggregateUi, which we don't natively support.
@@ -45702,7 +45710,7 @@ function dispatchSplitRecordAggregateUiAction(recordId, networkAdapter, resource
         }
         const merged = body.compositeResponse.reduce((seed, response) => {
             if (response.httpStatusCode !== HttpStatusCode$1.Ok) {
-                instrumentation$1$1.getRecordAggregateReject(() => recordId);
+                instrumentation$2.getRecordAggregateReject(() => recordId);
                 throw createErrorResponse(HttpStatusCode$1.ServerError, {
                     error: response.message,
                 });
@@ -45712,7 +45720,7 @@ function dispatchSplitRecordAggregateUiAction(recordId, networkAdapter, resource
             }
             return mergeRecordFields$2(seed, response.body);
         }, null);
-        instrumentation$1$1.getRecordAggregateResolve(() => {
+        instrumentation$2.getRecordAggregateResolve(() => {
             return {
                 recordId,
                 apiName: merged.apiName,
@@ -45720,7 +45728,7 @@ function dispatchSplitRecordAggregateUiAction(recordId, networkAdapter, resource
         });
         return createOkResponse$1(merged);
     }, (err) => {
-        instrumentation$1$1.getRecordAggregateReject(() => recordId);
+        instrumentation$2.getRecordAggregateReject(() => recordId);
         // rethrow error
         throw err;
     });
@@ -45798,7 +45806,7 @@ function buildAndDispatchGetRecordAggregateUi(recordId, req, params) {
     const { networkAdapter, resourceRequest, resourceRequestContext } = req;
     const compositeRequest = buildGetRecordByFieldsCompositeRequest(resourceRequest, params);
     // W-12245125: Emit chunk size metrics
-    instrumentation$1$1.aggregateUiChunkCount(() => compositeRequest.length);
+    instrumentation$2.aggregateUiChunkCount(() => compositeRequest.length);
     const aggregateUiParams = {
         compositeRequest,
     };
@@ -46032,7 +46040,7 @@ function platformNetworkAdapter(baseNetworkAdapter) {
     return (resourceRequest, resourceRequestContext) => {
         if (!tokenBucket.take(1)) {
             // We are hitting rate limiting, add some metrics
-            instrumentation$1$1.networkRateLimitExceeded();
+            instrumentation$2.networkRateLimitExceeded();
         }
         const salesforceRequest = {
             networkAdapter: baseNetworkAdapter,
@@ -88646,40 +88654,11 @@ function normalizeError$1(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 &&
@@ -88687,35 +88666,15 @@ const nimbusLogger = typeof __nimbus !== '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);
+    normalizeError$1(err);
 }
 function reportGraphqlSqlEvalPreconditionError(err) {
-    const error = normalizeError$1(err);
-    const errorCode = GRAPHQL_SQL_EVAL_PRECONDITION_ERROR;
-    // Metric
-    reportGraphqlAdapterError(errorCode);
-    // Log
-    ldsMobileInstrumentation$2.error(error, errorCode);
+    normalizeError$1(err);
 }
 function reportGraphqlCreateSnapshotError(err) {
-    const error = normalizeError$1(err);
-    const errorCode = GRAPHQL_CREATE_SNAPSHOT_ERROR;
-    // Metric
-    reportGraphqlAdapterError(errorCode);
-    // Log
-    ldsMobileInstrumentation$2.error(error, errorCode);
+    normalizeError$1(err);
 }
 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];
@@ -88727,52 +88686,15 @@ function reportGraphqlQueryInstrumentation(data) {
     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;
@@ -88782,43 +88704,16 @@ function reportDraftAwareContentDocumentVersionSynthesizeError(err) {
     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);
+    error.errorType;
 }
 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);
 }
 
 /**
@@ -88832,19 +88727,13 @@ 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);
     });
 };
 
@@ -89184,9 +89073,6 @@ function instrumentGraphQLEval(adapter) {
                     case 'graphql-query-instrumentation':
                         reportGraphqlQueryInstrumentation(data.data);
                         break;
-                    case 'graphql-luvio-refresh-undefined':
-                        incrementGraphQLRefreshUndfined();
-                        break;
                 }
             }
         },
@@ -89909,6 +89795,8 @@ const NimbusBinaryStore = {
     },
 };
 
+const priming_session_batch={namespace:"sf.lds",name:"PrimingSessionBatch",pbjsSchema:{"nested":{"sf":{"nested":{"lds":{"nested":{"PrimingSessionBatch":{"fields":{"container":{"id":8,"type":"string"},"idCount":{"id":1,"type":"uint32"},"missingCount":{"id":3,"type":"uint32"},"wasFromPagination":{"id":5,"type":"bool"},"successCount":{"id":2,"type":"uint32"},"paginationCount":{"id":6,"type":"uint32"},"conflictedCount":{"id":4,"type":"uint32"},"ingestDuration":{"id":7,"type":"double"}}}}}}}}}};
+
 class EventEmitter {
     constructor() {
         // @ts-ignore typescript doesn't like us setting this to an empty object for some reason
@@ -90022,6 +89910,12 @@ function buildFieldUnionArray(existingRecord, incomingRecord, objectInfo) {
                 fieldUnion.push(`${fieldName}.Id`);
                 includesSpanningFields = true;
             }
+            else {
+                // Field exists on record but not in object info.
+                // Fall back to getRecords resolver in this case.
+                fieldUnion.push(fieldName);
+                includesSpanningFields = true;
+            }
         }
         else {
             fieldUnion.push(fieldName);
@@ -90247,8 +90141,16 @@ class ConflictPool {
     }
 }
 
+const instrumentation$1$1 = getInstrumentation();
 const DEFAULT_BATCH_SIZE = 500;
 const DEFAULT_CONCURRENCY = 6;
+const MAX_RETRY_COUNT = 2;
+const SESSION_BATCH_SIZE = 'priming-session-batch-size';
+const SESSION_CONCURRENCY_LIMIT = 'priming-session-concurrency-limit';
+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';
 class PrimingSession extends EventEmitter {
     constructor(config) {
         super();
@@ -90260,6 +90162,9 @@ class PrimingSession extends EventEmitter {
         this.ldsRecordRefresher = config.ldsRecordRefresher;
         this.networkWorkerPool = new AsyncWorkerPool(this.concurrency);
         this.conflictPool = new ConflictPool(config.store, this.objectInfoLoader);
+        this.retryTracker = new Map();
+        instrumentation$1$1.trackValue(SESSION_BATCH_SIZE, config.batchSize ? config.batchSize : 0);
+        instrumentation$1$1.trackValue(SESSION_CONCURRENCY_LIMIT, config.concurrency ? config.concurrency : 0);
     }
     // function that enqueues priming work
     async enqueue(work) {
@@ -90278,6 +90183,9 @@ class PrimingSession extends EventEmitter {
             unavailableTypes,
         });
         if (unavailableIds.length > 0) {
+            for (const id of unavailableIds) {
+                this.retryTracker.delete(id);
+            }
             this.emit('error', {
                 ids: unavailableIds,
                 code: 'precondition-error',
@@ -90291,8 +90199,40 @@ class PrimingSession extends EventEmitter {
     cancel() {
         this.networkWorkerPool.cancel();
     }
-    enqueueBatches(batches) {
+    handleInstrumentation(activity, stats, errors) {
+        const schema = priming_session_batch;
+        const userData = {
+            ...stats,
+        };
+        if (errors.length) {
+            for (const error in errors) {
+                activity.error(error, schema, userData);
+            }
+        }
+        else {
+            activity.stop(schema, userData);
+        }
+    }
+    enqueueBatches(batches, paginationCount = 0) {
         for (const batch of batches) {
+            instrumentation$1$1.trackValue(SESSION_ENQUEUE_RECORD_COUNT, batch.ids.length);
+            const o11yActivity = instrumentation$1$1.startActivity('primingSessionBatch');
+            let stats = {
+                idCount: 0,
+                successCount: 0,
+                missingCount: 0,
+                conflictedCount: 0,
+                wasFromPagination: false,
+                paginationCount: 0,
+                ingestDuration: 0,
+                container: '',
+            };
+            let errors = [];
+            if (paginationCount > 0) {
+                stats.wasFromPagination = true;
+                stats.paginationCount = paginationCount;
+            }
+            stats.idCount = batch.ids.length;
             const queuedTime = Date.now();
             this.networkWorkerPool.push({
                 workFn: (abortController) => {
@@ -90302,6 +90242,9 @@ class PrimingSession extends EventEmitter {
                         .fetchRecordData(batch, abortController)
                         .then(async (results) => {
                         if (abortController.aborted) {
+                            for (const id of batch.ids) {
+                                this.retryTracker.delete(id);
+                            }
                             return;
                         }
                         this.emit('batch-fetched', {
@@ -90309,12 +90252,20 @@ class PrimingSession extends EventEmitter {
                             duration: Date.now() - workTime,
                         });
                         for (const result of results) {
-                            this.processFetchedRecords(result, abortController);
+                            const returnedError = this.processFetchedRecords(result, abortController, stats);
+                            if (returnedError) {
+                                errors.push(returnedError);
+                            }
                         }
-                        this.handlePaginations(results, batch);
+                        this.handlePaginations(results, batch, paginationCount);
+                    })
+                        .finally(() => {
+                        this.handleInstrumentation(o11yActivity, stats, errors);
                     });
                 },
                 cancelFn: () => {
+                    errors.push('cancelled');
+                    this.handleInstrumentation(o11yActivity, stats, errors);
                     this.emit('error', {
                         ids: batch.ids,
                         code: 'canceled',
@@ -90324,7 +90275,7 @@ class PrimingSession extends EventEmitter {
             });
         }
     }
-    handlePaginations(results, batch) {
+    handlePaginations(results, batch, paginationCount) {
         const ids = this.recordLoader.getMissingIdsWithPagination(results);
         if (ids.size > 0) {
             const batches = chunk(Array.from(ids), this.batchSize).map((chunkOfIds) => ({
@@ -90333,10 +90284,10 @@ class PrimingSession extends EventEmitter {
                 fields: batch.fields,
                 objectInfo: batch.objectInfo,
             }));
-            this.enqueueBatches(batches);
+            this.enqueueBatches(batches, paginationCount + 1);
         }
     }
-    processFetchedRecords(result, abortController) {
+    processFetchedRecords(result, abortController, stats) {
         if (result.ok === false) {
             const { error } = result;
             let primingError = 'unknown';
@@ -90351,10 +90302,14 @@ class PrimingSession extends EventEmitter {
                 code: primingError,
                 message: `${result.messages.join(',')}`,
             });
-            return;
+            for (const id of result.missingIds) {
+                this.retryTracker.delete(id);
+            }
+            return error;
         }
         const { missingIds } = result;
         if (missingIds.length > 0 && !this.recordLoader.isResultWithPagination(result)) {
+            stats.missingCount = missingIds.length;
             this.emit('error', {
                 ids: missingIds,
                 code: 'not-found',
@@ -90362,11 +90317,16 @@ class PrimingSession extends EventEmitter {
             });
         }
         const { records } = result;
+        stats.successCount = records.length;
         const beforeWrite = Date.now();
         // dispatch the write but DO NOT wait on it to unblock the network pool
         this.recordIngestor
             .insertRecords(records, false)
             .then(({ written, conflicted, errors }) => {
+            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);
+            stats.conflictedCount = conflicted.length;
             this.emit('batch-written', {
                 written,
                 conflicted,
@@ -90374,6 +90334,17 @@ class PrimingSession extends EventEmitter {
                 duration: Date.now() - beforeWrite,
             });
             if (abortController.aborted) {
+                for (const id of written) {
+                    this.retryTracker.delete(id);
+                }
+                for (const id of conflicted) {
+                    this.retryTracker.delete(id);
+                }
+                for (const error of errors) {
+                    for (const id of error.ids) {
+                        this.retryTracker.delete(id);
+                    }
+                }
                 return;
             }
             if (errors.length > 0) {
@@ -90383,11 +90354,17 @@ class PrimingSession extends EventEmitter {
                         code: 'unknown',
                         message: message,
                     });
+                    for (const id of ids) {
+                        this.retryTracker.delete(id);
+                    }
                 });
             }
             // now that the records are persisted, emit the primed event
             if (written.length > 0) {
                 this.emit('primed', Array.from(written));
+                for (const id of written) {
+                    this.retryTracker.delete(id);
+                }
             }
             // if any records could not be written to the store because there were conflicts, handle the conflicts
             if (conflicted.length > 0) {
@@ -90398,14 +90375,39 @@ class PrimingSession extends EventEmitter {
     async handleWriteConflicts(records, conflicted, abortController) {
         const result = await this.conflictPool.enqueueConflictedRecords(records.filter((x) => conflicted.includes(x.id)), abortController);
         if (abortController.aborted) {
+            for (const id of conflicted) {
+                this.retryTracker.delete(id);
+            }
             return;
         }
-        if (Object.keys(result.additionalWork.records).length > 0) {
+        if (keys$2$1(result.additionalWork.records).length > 0) {
             this.emit('conflict', {
                 ids: Object.values(result.additionalWork.records).flatMap((record) => record.ids),
                 resolution: 'priming-refresh',
             });
-            this.enqueue(result.additionalWork);
+            // we're re-enqueuing here, so apply retry limits which may change the batches
+            let limitedResult = this.applyRetryLimits(result.additionalWork);
+            this.enqueue(limitedResult.additionalWork);
+            if (limitedResult.recordsNeedingRefetch.size > 0) {
+                for (const key in keys$2$1(limitedResult.recordsNeedingRefetch)) {
+                    const value = limitedResult.recordsNeedingRefetch.get(key);
+                    if (result.recordsNeedingRefetch.has(key)) {
+                        let existing = result.recordsNeedingRefetch.get(key);
+                        existing = {
+                            // merge the ids
+                            ids: [...existing.ids, ...value.ids],
+                            // This is safe because they derive from the same
+                            // input, no chance of getting a new field in the
+                            // limited result
+                            fields: existing.fields,
+                        };
+                        result.recordsNeedingRefetch.set(key, existing);
+                    }
+                    else {
+                        result.recordsNeedingRefetch.set(key, value);
+                    }
+                }
+            }
         }
         if (result.resolvedRecords.length > 0) {
             this.emit('conflict', {
@@ -90413,8 +90415,14 @@ class PrimingSession extends EventEmitter {
                 resolution: 'priming-merge',
             });
             this.emit('primed', result.resolvedRecords);
+            for (const id of result.resolvedRecords) {
+                this.retryTracker.delete(id);
+            }
         }
         if (result.recordsToWrite.length > 0) {
+            for (const record of result.recordsToWrite) {
+                this.retryTracker.delete(record.id);
+            }
             const { written, errors, conflicted } = await this.recordIngestor.insertRecords(result.recordsToWrite, true);
             if (written.length > 0) {
                 const ids = Array.from(written);
@@ -90441,10 +90449,16 @@ class PrimingSession extends EventEmitter {
         if (result.recordsNeedingRefetch.size > 0) {
             const { loaded, errored } = await this.ldsRecordRefresher.loadRecords(result.recordsNeedingRefetch);
             if (loaded.length > 0) {
+                for (const id of loaded) {
+                    this.retryTracker.delete(id);
+                }
                 this.emit('conflict', { resolution: 'lds-refresh', ids: loaded });
                 this.emit('primed', loaded);
             }
             if (errored.length > 0) {
+                for (const id of errored) {
+                    this.retryTracker.delete(id);
+                }
                 this.emit('error', {
                     ids: errored,
                     code: 'unknown',
@@ -90453,6 +90467,50 @@ class PrimingSession extends EventEmitter {
             }
         }
     }
+    applyRetryLimits(primingWork) {
+        // retryable work goes back into priming session
+        let retryableWork = {
+            type: 'record-fields',
+            records: {},
+        };
+        // refetchable work gets delegated to getRecords
+        let refetchableWork = new Map();
+        for (const key of keys$2$1(primingWork.records)) {
+            let work = primingWork.records[key];
+            let limitedIds = [];
+            for (const id of work.ids) {
+                let retryCount = this.retryTracker.get(id) || 0;
+                retryCount += 1;
+                if (retryCount > MAX_RETRY_COUNT) {
+                    limitedIds.push(id);
+                    this.retryTracker.delete(id);
+                }
+                else {
+                    this.retryTracker.set(id, retryCount);
+                }
+            }
+            if (limitedIds.length < work.ids.length) {
+                retryableWork.records[key] = {
+                    ids: work.ids.filter((id) => limitedIds.indexOf(id) === -1),
+                    fields: work.fields,
+                };
+            }
+            if (limitedIds.length > 0) {
+                this.emit('retry-limit-reached', { ids: limitedIds });
+                refetchableWork.set(key, {
+                    ids: limitedIds,
+                    fields: work.fields,
+                });
+            }
+        }
+        return {
+            additionalWork: retryableWork,
+            recordsNeedingRefetch: refetchableWork,
+            resolvedRecords: [],
+            recordsToWrite: [],
+            errors: [],
+        };
+    }
     async fetchMetadata(batches) {
         const apiNames = Array.from(batches.reduce((acc, x) => {
             return acc.add(x.type);
@@ -90460,20 +90518,20 @@ class PrimingSession extends EventEmitter {
         const objectInfoMap = await this.objectInfoLoader.getObjectInfos(apiNames);
         const unavailableTypes = apiNames.filter((x) => !objectInfoMap[x]);
         const availableTypes = apiNames.filter((x) => objectInfoMap[x]);
-        const unavilableBatches = batches.filter((x) => unavailableTypes.includes(x.type));
+        const unavailableBatches = batches.filter((x) => unavailableTypes.includes(x.type));
         const availableBatches = batches
             .filter((x) => !unavailableTypes.includes(x.type))
             .map((x) => {
             return { ...x, objectInfo: objectInfoMap[x.type] };
         });
-        const unavailableIds = unavilableBatches.reduce((acc, x) => {
+        const unavailableIds = unavailableBatches.reduce((acc, x) => {
             acc.push(...x.ids);
             return acc;
         }, []);
         return {
             apiNames,
             availableBatches,
-            unavilableBatches,
+            unavailableBatches,
             unavailableTypes,
             availableTypes,
             unavailableIds,
@@ -90703,7 +90761,9 @@ class RecordLoaderGraphQL extends NetworkRecordLoader {
             return acc;
         }, {});
         fields['Id'] = { value: id, displayValue: null };
-        fields['RecordTypeId'] = { value: recordTypeId, displayValue: null };
+        if (objectInfo.fields['RecordTypeId'] !== undefined) {
+            fields['RecordTypeId'] = { value: recordTypeId, displayValue: null };
+        }
         let recordTypeInfo = null;
         if (recordTypeId !== null &&
             objectInfo.recordTypeInfos &&
@@ -90998,12 +91058,10 @@ 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);
@@ -92612,7 +92670,7 @@ function isStoreRecordError(storeRecord) {
     return storeRecord.__type === 'error';
 }
 
-const instrumentation$2 = getInstrumentation();
+const instrumentation$3 = getInstrumentation();
 const ProductConsumed = {
     API_NAME: 'ProductConsumed',
     Fields: {
@@ -92670,7 +92728,6 @@ class ProductConsumedUpdatedHook {
         const originalRecord = await this.durableRecordStore.getRecord(buildRecordRepKeyFromId$1(draftRecordId));
         if (originalRecord === undefined) {
             incrementCounter(ProductConsumedUpdatedHook.COUNTER_NAME, CounterResult.Error);
-            instrumentation$2.error(`SFS - ProductConsumedUpdatedHook - Original record ${draftRecordId} not found`);
             return [];
         }
         const originalProductItemId = getProductItemIdFromRecordFields(originalRecord.fields);
@@ -92681,7 +92738,6 @@ class ProductConsumedUpdatedHook {
         }
         if (originalQuantityConsumed === undefined) {
             incrementCounter(ProductConsumedUpdatedHook.COUNTER_NAME, CounterResult.Error);
-            instrumentation$2.error(`SFS - ProductConsumedUpdatedHook - Original record ${draftRecordId} QuantityConsumed not found`);
             return [];
         }
         incrementCounter(ProductConsumedUpdatedHook.COUNTER_NAME, CounterResult.Created);
@@ -92708,7 +92764,6 @@ class ProductConsumedDeletedHook {
         const originalRecord = await this.durableRecordStore.getRecord(buildRecordRepKeyFromId$1(draftRecordId));
         if (originalRecord === undefined) {
             incrementCounter(ProductConsumedDeletedHook.COUNTER_NAME, CounterResult.Error);
-            instrumentation$2.error(`SFS - ProductConsumedDeletedHook - Original record ${draftRecordId} not found`);
             return [];
         }
         const productItemId = getProductItemIdFromRecordFields(originalRecord.fields);
@@ -92719,7 +92774,6 @@ class ProductConsumedDeletedHook {
         }
         if (quantityConsumed === undefined) {
             incrementCounter(ProductConsumedDeletedHook.COUNTER_NAME, CounterResult.Error);
-            instrumentation$2.error(`SFS - ProductConsumedDeletedHook - Original record ${draftRecordId} QuantityConsumed not found`);
             return [];
         }
         incrementCounter(ProductConsumedDeletedHook.COUNTER_NAME, CounterResult.Created);
@@ -92774,7 +92828,7 @@ var CounterResult;
     CounterResult["Error"] = "Error";
 })(CounterResult || (CounterResult = {}));
 function incrementCounter(name, result) {
-    instrumentation$2.incrementCounter('SFSSideEffect', 1, result == CounterResult.Error, {
+    instrumentation$3.incrementCounter('SFSSideEffect', 1, result == CounterResult.Error, {
         Name: name,
         Result: result,
     });
@@ -92979,7 +93033,7 @@ register$1({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$2,
 });
-// version: 1.351.1-fe0298cc85
+// version: 1.353.0-cc9b469dc4
 
 const { create: create$2, keys: keys$2 } = Object;
 const { stringify, parse } = JSON;
@@ -116874,7 +116928,7 @@ register$1({
     configuration: { ...configurationForGraphQLAdapters$1 },
     instrument: instrument$1,
 });
-// version: 1.351.1-3c191568b9
+// version: 1.353.0-330d59cfcb
 
 // On core the unstable adapters are re-exported with different names,
 // we want to match them here.
@@ -117026,7 +117080,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.351.1-3c191568b9
+// version: 1.353.0-330d59cfcb
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -117818,7 +117872,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.351.1-fe0298cc85
+// version: 1.353.0-cc9b469dc4
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -118898,4 +118952,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, evictExpiredCacheEntries, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToMerge, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, stopEviction, subscribeToAdapter };
-// version: 1.351.1-fe0298cc85
+// version: 1.353.0-cc9b469dc4