@salesforce/lds-worker-api 1.253.0 → 1.256.0

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

@@ -3976,7 +3976,7 @@ function createResourceParamsImpl(config, configMetadata) {
     }
     return resourceParams;
 }
-// engine version: 0.153.0-32ab5c05
+// engine version: 0.154.3-c6624f8e
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -4104,7 +4104,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.253.0-5f7477b3b
+// version: 1.256.0-ad6a66c18
 
 // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
 function instrumentAdapter$1(createFunction, _metadata) {
@@ -15612,7 +15612,7 @@ function gql(literals, ...subs) {
     }
     return superResult;
 }
-// version: 1.253.0-5f7477b3b
+// version: 1.256.0-ad6a66c18
 
 function unwrap(data) {
     // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16537,7 +16537,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     const { apiFamily, name } = metadata;
     return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
-// version: 1.253.0-5f7477b3b
+// version: 1.256.0-ad6a66c18
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -16636,7 +16636,7 @@ var TypeCheckShapes;
     TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
     TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
 })(TypeCheckShapes || (TypeCheckShapes = {}));
-// engine version: 0.153.0-32ab5c05
+// engine version: 0.154.3-c6624f8e
 
 const { keys: ObjectKeys$3, create: ObjectCreate$3 } = Object;
 
@@ -42765,7 +42765,7 @@ withDefaultLuvio((luvio) => {
     throttle(60, 60000, createLDSAdapter(luvio, 'notifyListInfoUpdateAvailable', notifyUpdateAvailableFactory$1));
     throttle(60, 60000, createLDSAdapter(luvio, 'notifyQuickActionDefaultsUpdateAvailable', notifyUpdateAvailableFactory));
 });
-// version: 1.253.0-15fc9805a
+// version: 1.256.0-fb019fbad
 
 var ldsIdempotencyWriteDisabled = {
     isOpen: function (e) {
@@ -42776,6 +42776,15 @@ var ldsIdempotencyWriteDisabled = {
     },
 };
 
+var ldsBackdatingEnabled = {
+    isOpen: function (e) {
+        return e.fallback;
+    },
+    hasError: function () {
+        return !0;
+    },
+};
+
 var caseSensitiveUserId = '005B0000000GR4OIAW';
 
 function requestIdleDetectedCallback(_callback) { }
@@ -42799,6 +42808,24 @@ const idleDetector = {
     declareNotifierTaskMulti,
     declarePollableTaskMulti,
 };
+function stop(_userSchemaOrText, _userData) { }
+function error(_error, _userSchemaOrText, _userData) { }
+const activity = {
+    stop,
+    error,
+};
+function startActivity(_name) {
+    return activity;
+}
+const mockInstrumentation = {
+    startActivity,
+    error: () => { },
+    trackValue: (_operation, _value, _hasError, _tags) => { },
+    incrementCounter: (_operation, _increment, _hasError, _tags) => { },
+};
+const getInstrumentation = () => {
+    return mockInstrumentation;
+};
 
 var ldsUseShortUrlGate = {
     isOpen: function (e) {
@@ -47226,8 +47253,9 @@ function rootRecordQuery(selection, input) {
         // If there is no metadata for this query or it somehow lacks a timestamp
         // skip setting the root timestamp
         if (queryMetadata !== undefined && queryMetadata.ingestionTimestamp !== undefined) {
-            // subtract 1000ms from timestamp to account for ingestion processing time
-            input.rootTimestamp = queryMetadata.ingestionTimestamp - 1000;
+            // adjust the timestamp to account for ingestion processing time
+            // 30s is used because this is the default record TTL
+            input.rootTimestamp = queryMetadata.ingestionTimestamp - 30000;
         }
     }
     return recordQuery(selection, alias, apiName, [], input);
@@ -48896,6 +48924,8 @@ class DurableDraftStore {
     }
 }
 
+const DEFAULT_FIELD_LAST_MODIFIED_DATE$1 = 'LastModifiedDate';
+const DEFAULT_FIELD_CREATED_DATE$1 = 'CreatedDate';
 class AbstractResourceRequestActionHandler {
     constructor(draftQueue, networkAdapter, getLuvio) {
         this.draftQueue = draftQueue;
@@ -48914,6 +48944,7 @@ class AbstractResourceRequestActionHandler {
         this.isLdsIdempotencyWriteDisabled = ldsIdempotencyWriteDisabled.isOpen({
             fallback: false,
         });
+        this.isBackdatingEnabled = ldsBackdatingEnabled.isOpen({ fallback: false });
     }
     enqueue(data) {
         return this.draftQueue.enqueue(this.handlerId, data);
@@ -48984,6 +49015,17 @@ class AbstractResourceRequestActionHandler {
                     }
                 }
             }
+            if (this.isBackdatingEnabled &&
+                response.status === HttpStatusCode$1.BadRequest &&
+                this.isBackdatingError(response.body, action)) {
+                updatedAction.timestamp = Date.now();
+                updatedAction.data.body.fields = {
+                    ...updatedAction.data.body.fields,
+                    LastModifiedDate: new Date(updatedAction.timestamp).toISOString(),
+                };
+                shouldRetry = true;
+                actionDataChanged = true;
+            }
             await actionErrored(shouldRetry
                 ? updatedAction
                 : {
@@ -49017,7 +49059,21 @@ class AbstractResourceRequestActionHandler {
     }
     // checks if the body is an array of UiApiError. Sometimes the body has `enhancedErrorType` field as an error indicator(one example is the field validation failure). In such case Action being processed updates to an Error Action.
     isUiApiErrors(body) {
-        return body !== undefined && Array.isArray(body) && body.length > 0 && body[0].errorCode;
+        return body !== undefined && isArray$3$1(body) && body.length > 0 && body[0].errorCode;
+    }
+    isBackdatingError(body, action) {
+        if (body.enhancedErrorType &&
+            body.enhancedErrorType === 'RecordError' &&
+            body.output &&
+            body.output.errors &&
+            isArray$3$1(body.output.errors) &&
+            body.output.errors.length > 0 &&
+            action.data.body &&
+            action.data.body.fields &&
+            action.data.body.fields[DEFAULT_FIELD_LAST_MODIFIED_DATE$1]) {
+            return body.output.errors.some((error) => error.errorCode === 'CollisionDetectedException');
+        }
+        return false;
     }
     async buildPendingAction(request, queue) {
         const targetId = await this.getIdFromRequest(request);
@@ -49959,7 +50015,7 @@ function isArrayLike(x) {
 
 const { create: create$4, keys: keys$4, values: values$2, entries: entries$3, assign: assign$4 } = Object;
 const { stringify: stringify$4, parse: parse$4 } = JSON;
-const { isArray: isArray$2$1, from: from$1 } = Array;
+const { isArray: isArray$2$1, from: from$2 } = Array;
 
 function recordLoaderFactory(query) {
     async function batchRecordQuery(ids) {
@@ -52173,8 +52229,9 @@ async function fetchIngestionTimeStampFromDatabase(apiName, info, args, query) {
         const results = await query(sql, [key]);
         const [timestamp] = results.rows.map((row) => row[0]);
         if (timestamp !== null && typeof timestamp === 'number') {
-            //go back 1000 ms to adjust for margin of error when top level query is stored and when raml objects are stored
-            ingestionTimestamp = timestamp - 1000;
+            // adjust the timestamp to account for ingestion processing time
+            // 30s is used because this is the default record TTL
+            ingestionTimestamp = timestamp - 30000;
         }
     }
     return ingestionTimestamp;
@@ -52330,7 +52387,7 @@ function generateRecordQueries(schema, objectInfoMap) {
         recordQueries: extensionWrapper,
         recordConnections,
         recordExtensions,
-        polyFieldTypeNameArr: from$1(allPolymorphicFieldTypeNames),
+        polyFieldTypeNameArr: from$2(allPolymorphicFieldTypeNames),
     };
 }
 /**
@@ -54304,7 +54361,7 @@ function referenceIdFieldForRelationship(relationshipName) {
 const { keys: keys$3$1, values: values$1, create: create$3$1, assign: assign$3, freeze: freeze$3 } = Object;
 const { stringify: stringify$3, parse: parse$3 } = JSON;
 const { shift } = Array.prototype;
-const { isArray: isArray$1$1 } = Array;
+const { isArray: isArray$1$1, from: from$1 } = Array;
 
 function isFieldLink(field) {
     const { value } = field;
@@ -55098,7 +55155,7 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
     }
     async buildPendingAction(request, queue) {
         const resolvedRequest = this.resolveResourceRequest(request);
-        const pendingAction = (await super.buildPendingAction(resolvedRequest, queue));
+        let pendingAction = (await super.buildPendingAction(resolvedRequest, queue));
         const { tag, targetId } = pendingAction;
         const targetApiName = await this.getApiNameForRecordId(targetId, tag, resolvedRequest);
         pendingAction.metadata[LDS_ACTION_METADATA_API_NAME] = targetApiName;
@@ -55144,8 +55201,49 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
                 this.fetchReferenceRecord(referenceFields);
             }
         }
+        // handles backdating
+        if (this.isBackdatingEnabled &&
+            pendingAction.data &&
+            pendingAction.data.method !== 'delete' && //'delete' action does not have fields
+            metaDataResult.data &&
+            metaDataResult.data.objectInfos) {
+            const objectInfo = metaDataResult.data.objectInfos.get(targetApiName);
+            if (objectInfo === undefined) {
+                throw Error(`Could not generate draft. Object info is missing`);
+            }
+            const appendedFields = this.getBackdatingFields(objectInfo, resolvedRequest.method, pendingAction);
+            if (keys$3$1(appendedFields).length > 0) {
+                pendingAction.data.body = {
+                    ...pendingAction.data.body,
+                    fields: {
+                        ...pendingAction.data.body.fields,
+                        ...appendedFields,
+                    },
+                };
+            }
+        }
         return pendingAction;
     }
+    getBackdatingFields(objectInfo, requestMethod, pendingAction) {
+        const fields = {};
+        const actionFieldNames = keys$3$1(pendingAction.data.body.fields);
+        if (requestMethod === 'post') {
+            // `CreateRecord` with `CreatedDate` field
+            if (isBackdatingFieldEditable(objectInfo, DEFAULT_FIELD_CREATED_DATE$1, 'createable', actionFieldNames)) {
+                fields[DEFAULT_FIELD_CREATED_DATE$1] = new Date(pendingAction.timestamp).toISOString();
+            }
+            // `CreateRecord` with `LastModifiedDate` field
+            if (isBackdatingFieldEditable(objectInfo, DEFAULT_FIELD_LAST_MODIFIED_DATE$1, 'createable', actionFieldNames)) {
+                fields[DEFAULT_FIELD_LAST_MODIFIED_DATE$1] = new Date(pendingAction.timestamp).toISOString();
+            }
+        }
+        // `UpdateRecord` with `LastModifedDate` field
+        if (requestMethod === 'patch' &&
+            isBackdatingFieldEditable(objectInfo, DEFAULT_FIELD_LAST_MODIFIED_DATE$1, 'updateable', actionFieldNames)) {
+            fields[DEFAULT_FIELD_LAST_MODIFIED_DATE$1] = new Date(pendingAction.timestamp).toISOString();
+        }
+        return fields;
+    }
     async fetchReferenceRecord(referenceFields) {
         const promises = referenceFields.map(async (referenceFieldInfo) => {
             const apiName = await this.identifyApiName(referenceFieldInfo.id, referenceFieldInfo.field);
@@ -55436,12 +55534,26 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
     mergeRequestBody(targetBody, sourceBody) {
         // IMPORTANT: spread operator isn't deep clone so we have to individually
         // spread nested objects (just "fields" for RecordInputReps)
+        const targetInput = targetBody;
+        const sourceInput = sourceBody;
+        // choose the max if both source and target have the `LastModifiedDate` property.
+        // there is no need to check 'CreatedDate` since source and target cannot be `create` action at the same time
+        const lastModifiedFields = {};
+        const targetLastModifiedField = targetInput.fields[DEFAULT_FIELD_LAST_MODIFIED_DATE$1];
+        const sourceLastModifiedField = sourceInput.fields[DEFAULT_FIELD_LAST_MODIFIED_DATE$1];
+        if (targetLastModifiedField && sourceLastModifiedField) {
+            lastModifiedFields[DEFAULT_FIELD_LAST_MODIFIED_DATE$1] =
+                targetLastModifiedField > sourceLastModifiedField
+                    ? targetLastModifiedField
+                    : sourceLastModifiedField;
+        }
         return {
             ...targetBody,
             ...sourceBody,
             fields: {
                 ...targetBody.fields,
                 ...sourceBody.fields,
+                ...lastModifiedFields,
             },
         };
     }
@@ -55449,6 +55561,13 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
 function isField(key, data) {
     return isStoreKeyRecordField(key);
 }
+// true if `createable/updateable` property of backdating field is true and draft does not include that fields. If the customer specifies
+// `LastModifiedDate`, it is not overwritten.
+function isBackdatingFieldEditable(objectInfo, backdatingFieldName, attributeName, draftActionFieldNames) {
+    return (objectInfo.fields[backdatingFieldName] &&
+        objectInfo.fields[backdatingFieldName][attributeName] &&
+        !draftActionFieldNames.includes(backdatingFieldName));
+}
 
 /**
  * Records are stored in the durable store with scalar fields denormalized. This function takes that denoramlized
@@ -56483,7 +56602,7 @@ class ContentDocumentCompositeRepresentationActionHandler extends AbstractResour
         });
         pendingAction.metadata[CONTENT_DOCUMENT_LINK_DRAFT_ID_KEY] = contentDocumentLinkId;
         // assert that object infos and references exist
-        const metaDataResult = await this.draftRecordService.getRecordDraftMetadata(targetId, pendingAction);
+        const metaDataResult = await this.draftRecordService.getRecordDraftMetadata(contentVersionId, pendingAction);
         if (metaDataResult === undefined) {
             throw Error('No metadata for draft');
         }
@@ -56497,8 +56616,30 @@ class ContentDocumentCompositeRepresentationActionHandler extends AbstractResour
                     throw new DraftSynthesisError(`unknown draft precondition failed, metaDataResult: ${JSON.stringify(metaDataResult)}`, 'UNKNOWN');
             }
         }
+        else if (this.isBackdatingEnabled) {
+            const contentVersionObjectInfo = metaDataResult.data.objectInfos.get(CONTENT_VERSION_API_NAME);
+            if (contentVersionObjectInfo === undefined) {
+                throw Error(`Could not generate draft. Object info is missing`);
+            }
+            // `ContentVersion` support back-dating. Ui-api team has WI @W-14219481  to support `CreatedDate` and `LastModifiedDate`.
+            // right now, these two fields are ignored by server
+            pendingAction.data.body.namedEntries = [
+                ...pendingAction.data.body.namedEntries,
+                ...this.getBackdatingNameEntries(contentVersionObjectInfo, pendingAction.timestamp),
+            ];
+        }
         return pendingAction;
     }
+    getBackdatingNameEntries(objectInfo, timestamp) {
+        return [DEFAULT_FIELD_CREATED_DATE$1, DEFAULT_FIELD_LAST_MODIFIED_DATE$1]
+            .filter((fieldName) => objectInfo.fields[fieldName] && objectInfo.fields[fieldName].createable)
+            .map((fieldValue) => {
+            return {
+                name: fieldValue,
+                value: new Date(timestamp).toISOString(),
+            };
+        });
+    }
     /* istanbul ignore next */
     canHandlePublish(_key) {
         // no need to touch publishing
@@ -60260,7 +60401,7 @@ register$1({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$2,
 });
-// version: 1.253.0-5f7477b3b
+// version: 1.256.0-ad6a66c18
 
 const { create: create$3, keys: keys$3 } = Object;
 const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -78589,7 +78730,7 @@ register$1({
     configuration: { ...configurationForGraphQLAdapters$1 },
     instrument: instrument$1,
 });
-// version: 1.253.0-15fc9805a
+// version: 1.256.0-fb019fbad
 
 // On core the unstable adapters are re-exported with different names,
 // we want to match them here.
@@ -80839,7 +80980,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.253.0-15fc9805a
+// version: 1.256.0-fb019fbad
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -81537,7 +81678,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.253.0-5f7477b3b
+// version: 1.256.0-ad6a66c18
 
 /**
  * Returns true if the value acts like a Promise, i.e. has a "then" function,
@@ -86187,15 +86328,11 @@ function removeEventHandler(session, handler) {
     }
 }
 
-var EvictStatus;
-(function (EvictStatus) {
-    EvictStatus["Started"] = "Started";
-    EvictStatus["Running"] = "Running";
-    EvictStatus["Evicted"] = "Evicted";
-    EvictStatus["Succeeded"] = "Succeeded";
-    EvictStatus["Error"] = "Error";
-    EvictStatus["Canceled"] = "Canceled";
-})(EvictStatus || (EvictStatus = {}));
+const evict_cache_records_by_ids={namespace:"sf.lds",name:"EvictCacheRecordsByIds",pbjsSchema:{"nested":{"sf":{"nested":{"lds":{"nested":{"EvictCacheRecordsByIds":{"fields":{"idCount":{"id":1,"type":"uint32"},"isCanceled":{"id":4,"type":"bool"},"evictedCount":{"id":2,"type":"uint32"},"skippedCount":{"id":3,"type":"uint32"}}}}}}}}}};
+
+const evict_expired_entries={namespace:"sf.lds",name:"EvictExpiredEntries",pbjsSchema:{"nested":{"sf":{"nested":{"lds":{"nested":{"EvictExpiredEntries":{"fields":{"isCanceled":{"id":3,"type":"bool"},"expiredInDays":{"id":1,"type":"uint32"},"evictedCount":{"id":2,"type":"uint32"}}}}}}}}}};
+
+const ldsMobileInstrumentation = getInstrumentation();
 const MessagingDurableSegmentName = 'MESSAGING';
 const DEFAULT_MAX_ENTRIES_PER_OPERATION = 500;
 const EVICTION_IN_PROGESS_MESSAGE = `Cache eviction in progress. Can't start another until it is finished or canceled.`;
@@ -86218,18 +86355,27 @@ function evictCacheRecordsByIds(recordIds, onProgressUpdate) {
     // Send error back if an eviction is going on.
     if (activeEvictionInProgress) {
         return {
-            status: EvictStatus.Running,
+            status: 'Running',
             message: EVICTION_IN_PROGESS_MESSAGE,
         };
     }
     activeEvictionInProgress = true;
     cancelCurrentEviction = false;
+    const o11yActivity = ldsMobileInstrumentation.startActivity('evictCacheRecordsByIds');
+    const stat = {
+        idCount: recordIds.length,
+        evictedCount: 0,
+        skippedCount: 0,
+    };
     const evictAChunk = () => {
-        evictChunksOfRecord(recordIds).then(onEvicted);
+        evictChunksOfRecord(recordIds).then((progress) => {
+            handleInstrumentation(o11yActivity, stat, progress);
+            onEvicted(progress);
+        });
     };
-    const onEvicted = getOnEvictedCallback(onProgressUpdate, evictAChunk);
+    const onEvicted = getOnEvictedCallback(o11yActivity, onProgressUpdate, evictAChunk, stat);
     evictAChunk();
-    return { status: EvictStatus.Started };
+    return { status: 'Started' };
 }
 /**
  * Purging the db entries which passed expired time by specified days
@@ -86245,19 +86391,28 @@ function evictExpiredCacheEntries(expiredByDays, onProgressUpdate) {
     // Send error back if an eviction is going on.
     if (activeEvictionInProgress) {
         return {
-            status: EvictStatus.Running,
+            status: 'Running',
             message: EVICTION_IN_PROGESS_MESSAGE,
         };
     }
     activeEvictionInProgress = true;
     cancelCurrentEviction = false;
+    const stat = {
+        expiredInDays: expiredByDays,
+        evictedCount: 0,
+        skippedCount: 0,
+    };
+    const o11yActivity = ldsMobileInstrumentation.startActivity('evictExpiredCacheEntries');
     const overdueExpirationTimeStamp = Date.now() - expiredByDays * 24 * 3600 * 1000;
     const evictAChunk = () => {
-        evictChunkOfOverdueEntries(overdueExpirationTimeStamp).then(onEvicted);
+        evictChunkOfOverdueEntries(overdueExpirationTimeStamp).then((progress) => {
+            handleInstrumentation(o11yActivity, stat, progress);
+            onEvicted(progress);
+        });
     };
-    const onEvicted = getOnEvictedCallback(onProgressUpdate, evictAChunk);
+    const onEvicted = getOnEvictedCallback(o11yActivity, onProgressUpdate, evictAChunk, stat);
     evictAChunk();
-    return { status: EvictStatus.Started };
+    return { status: 'Started' };
 }
 /**
  * Signal to stop current eviction if there's an active eviction going on.
@@ -86273,17 +86428,19 @@ function stopEviction() {
  * @param evictAChunk
  * @returns a callback to call when a chunk of records or entries are removed.
  */
-function getOnEvictedCallback(onProgressUpdate, evictAChunk) {
+function getOnEvictedCallback(o11yActivity, onProgressUpdate, evictAChunk, stat) {
     return (progress) => {
         onProgressUpdate(progress);
         const { status } = progress;
-        if (status === EvictStatus.Succeeded || status === EvictStatus.Error) {
+        if (status === 'Succeeded' || status === 'Error') {
             activeEvictionInProgress = false;
         }
-        if (status === EvictStatus.Evicted) {
+        if (status === 'Evicted') {
             if (cancelCurrentEviction) {
                 activeEvictionInProgress = false;
-                onProgressUpdate({ status: EvictStatus.Canceled });
+                const canceledProgress = { status: 'Canceled' };
+                onProgressUpdate(canceledProgress);
+                handleInstrumentation(o11yActivity, stat, canceledProgress);
             }
             else {
                 evictAChunk();
@@ -86299,7 +86456,7 @@ function getOnEvictedCallback(onProgressUpdate, evictAChunk) {
 function evictChunksOfRecord(ids) {
     const chunk = ids.splice(0, DEFAULT_MAX_ENTRIES_PER_OPERATION);
     if (chunk.length === 0) {
-        return Promise.resolve({ status: EvictStatus.Succeeded });
+        return Promise.resolve({ status: 'Succeeded' });
     }
     return new Promise((resolve) => {
         // evict the chunk
@@ -86320,22 +86477,22 @@ function evictChunksOfRecord(ids) {
                     nimbusSqliteStore.setEntries({ notifyStoreUpdateAvailable: { data: evictedEntries } }, MessagingDurableSegmentName);
                 }
                 resolve({
-                    status: EvictStatus.Evicted,
+                    status: 'Evicted',
                     evictedEntries,
                     skippedEntries,
                 });
             })
                 .catch((reason) => {
                 resolve({
-                    status: EvictStatus.Error,
-                    message: JSON.stringify(reason),
+                    status: 'Error',
+                    message: reason.toString(),
                 });
             });
         }
         catch (reason) {
             resolve({
-                status: EvictStatus.Error,
-                message: JSON.stringify(reason),
+                status: 'Error',
+                message: reason.toString(),
             });
         }
     });
@@ -86374,30 +86531,50 @@ function evictChunkOfOverdueEntries(overdueExpirationTimestamp) {
                     // broadcast entries evicted
                     nimbusSqliteStore.setEntries({ notifyStoreUpdateAvailable: { data: evictedEntries } }, MessagingDurableSegmentName);
                     resolve({
-                        status: EvictStatus.Evicted,
+                        status: 'Evicted',
                         evictedEntries,
                         skippedEntries: [],
                     });
                 }
                 else {
-                    resolve({ status: EvictStatus.Succeeded });
+                    resolve({ status: 'Succeeded' });
                 }
             })
                 .catch((reason) => {
                 resolve({
-                    status: EvictStatus.Error,
-                    message: JSON.stringify(reason),
+                    status: 'Error',
+                    message: reason.toString(),
                 });
             });
         }
         catch (reason) {
             resolve({
-                status: EvictStatus.Error,
-                message: JSON.stringify(reason),
+                status: 'Error',
+                message: reason.toString(),
             });
         }
     });
 }
+function handleInstrumentation(activity, stat, progress) {
+    const status = progress.status;
+    if (status === 'Evicted') {
+        const evicted = progress;
+        stat.evictedCount += evicted.evictedEntries.length;
+        stat.skippedCount += evicted.skippedEntries.length;
+        return;
+    }
+    const schema = 'idCount' in stat ? evict_cache_records_by_ids : evict_expired_entries;
+    const userData = {
+        ...stat,
+        isCanceled: status === 'Canceled',
+    };
+    if (status === 'Error') {
+        activity.error(progress.message, schema, userData);
+    }
+    else if (status === 'Succeeded' || status === 'Canceled') {
+        activity.stop(schema, userData);
+    }
+}
 
 // LWR has a "setupLDS" bootstrap service/loader hook, we simulate this in
 // standalone bundle by mimicking what "setupLDS" does here and then exporting
@@ -86406,4 +86583,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, evictExpiredCacheEntries, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, stopEviction, subscribeToAdapter };
-// version: 1.253.0-5f7477b3b
+// version: 1.256.0-ad6a66c18

package/dist/standalone/es/types/cachePurging.d.ts

@@ -1,32 +1,24 @@
-declare enum EvictStatus {
-    Started = "Started",
-    Running = "Running",
-    Evicted = "Evicted",
-    Succeeded = "Succeeded",
-    Error = "Error",
-    Canceled = "Canceled"
-}
 interface EvictStarted {
-    status: EvictStatus.Started;
+    status: 'Started';
 }
 interface EvictRunning {
-    status: EvictStatus.Running;
+    status: 'Running';
     message: string;
 }
 interface BatchEvicted {
-    status: EvictStatus.Evicted;
-    skippedEntries?: string[];
-    evictedEntries?: string[];
+    status: 'Evicted';
+    skippedEntries: string[];
+    evictedEntries: string[];
 }
 interface EvictSucceeded {
-    status: EvictStatus.Succeeded;
+    status: 'Succeeded';
 }
 interface EvictError {
-    status: EvictStatus.Error;
+    status: 'Error';
     message: string;
 }
 interface EvictCancelled {
-    status: EvictStatus.Canceled;
+    status: 'Canceled';
 }
 export type EvictProgress = BatchEvicted | EvictSucceeded | EvictError | EvictCancelled;
 export type ProgressUpdateCallback = (progess: EvictProgress) => void;