@salesforce/lds-worker-api 1.208.1 → 1.210.0

package/dist/sfdc/es/ldsWorkerApi.js

@@ -743,22 +743,47 @@ function createPrimingSession(config) {
     const { primingEventHandler, concurrency, batchSize } = config;
     const session = createPrimingSession({ concurrency, batchSize });
     if (primingEventHandler) {
-        const { onError, onPrimed } = primingEventHandler;
-        if (onError) {
-            session.on('error', onError.bind(primingEventHandler));
-        }
-        if (onPrimed) {
-            session.on('primed', onPrimed.bind(primingEventHandler));
-        }
-    }
+        addEventHandler(session, primingEventHandler);
+    }
+    const registerEventHandler = (handler) => {
+        // bind creates a new function and we need to retain reference to that function
+        // in order to be able to remove it
+        const boundCallbacks = {
+            onError: handler.onError ? handler.onError.bind(handler) : undefined,
+            onPrimed: handler.onPrimed ? handler.onPrimed.bind(handler) : undefined,
+        };
+        addEventHandler(session, boundCallbacks);
+        return () => {
+            removeEventHandler(session, boundCallbacks);
+        };
+    };
     return {
         enqueue: session.enqueue.bind(session),
         cancel: session.cancel.bind(session),
         on: session.on.bind(session),
         once: session.once.bind(session),
         off: session.off.bind(session),
+        registerEventHandler,
     };
 }
+function addEventHandler(session, handler) {
+    const { onError, onPrimed } = handler;
+    if (onError) {
+        session.on('error', onError);
+    }
+    if (onPrimed) {
+        session.on('primed', onPrimed);
+    }
+}
+function removeEventHandler(session, handler) {
+    const { onError, onPrimed } = handler;
+    if (onError) {
+        session.off('error', onError);
+    }
+    if (onPrimed) {
+        session.off('primed', onPrimed);
+    }
+}
 
 if (process.env.NODE_ENV !== 'production') {
     // eslint-disable-next-line no-undef
@@ -770,4 +795,4 @@ if (process.env.NODE_ENV !== 'production') {
 }
 
 export { createPrimingSession, draftManager, draftQueue, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, setMetadataTTL, setUiApiRecordTTL, subscribeToAdapter };
-// version: 1.208.1-8f4c4550e
+// version: 1.210.0-b2655462f

package/dist/sfdc/es/types/primingApi.d.ts

@@ -1,10 +1,11 @@
+import type { PrimingSession } from '@salesforce/lds-priming';
 interface PrimingError {
     ids: string[];
     code: ErrorCode;
     message: string;
 }
 type ErrorCode = 'precondition-error' | 'not-found' | 'service-unavailable' | 'canceled' | 'unknown';
-interface PrimingEventHandler {
+export interface PrimingEventHandler {
     onError?: (error: PrimingError) => void;
     onPrimed?: (ids: string[]) => void;
 }
@@ -16,8 +17,9 @@ export interface PrimingSessionConfig {
 export declare function createPrimingSession(config: PrimingSessionConfig): {
     enqueue: (work: PrimingWork) => Promise<void>;
     cancel: () => void;
-    on: <K extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K]) => void) => import("@salesforce/lds-priming").PrimingSession;
-    once: <K_1 extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K_1, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K_1]) => void) => import("@salesforce/lds-priming").PrimingSession;
-    off: <K_2 extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K_2, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K_2]) => void) => import("@salesforce/lds-priming").PrimingSession;
+    on: <K extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K]) => void) => PrimingSession;
+    once: <K_1 extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K_1, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K_1]) => void) => PrimingSession;
+    off: <K_2 extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K_2, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K_2]) => void) => PrimingSession;
+    registerEventHandler: (handler: PrimingEventHandler) => () => void;
 };
 export {};

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

@@ -3862,7 +3862,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.208.1-8f4c4550e
+// version: 1.210.0-b2655462f
 
 // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
 function instrumentAdapter$1(createFunction, _metadata) {
@@ -15295,7 +15295,7 @@ function parseAndVisit(source) {
     updateReferenceMapWithKnownKey(ast, luvioDocumentNode);
     return luvioDocumentNode;
 }
-// version: 1.208.1-8f4c4550e
+// version: 1.210.0-b2655462f
 
 function unwrap(data) {
     // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16218,7 +16218,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     const { apiFamily, name } = metadata;
     return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
-// version: 1.208.1-8f4c4550e
+// version: 1.210.0-b2655462f
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -43556,7 +43556,7 @@ withDefaultLuvio((luvio) => {
     });
     throttle(60, 60000, createLDSAdapter(luvio, 'notifyListViewSummaryUpdateAvailable', notifyUpdateAvailableFactory));
 });
-// version: 1.208.1-9aaa359ad
+// version: 1.210.0-2883d2f5f
 
 var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -58066,6 +58066,8 @@ function reportDraftAwareContentVersionSynthesizeCalls(mimeType) {
 }
 function reportPrimingError(errorType, recordCount) {
 }
+function reportPrimingConflict(resolutionType, recordCount) {
+}
 
 /**
  * HOF (high-order-function) that instruments any async operation.  If the operation
@@ -59041,6 +59043,245 @@ function generateTypedBatches(work, batchSize) {
     return batches;
 }
 
+function getMissingElementsFromSuperset(superset, subset) {
+    return subset.filter((val) => !superset.includes(val));
+}
+function findReferenceFieldForSpanningField(fieldName, objectInfo) {
+    const fieldNames = Object.keys(objectInfo.fields);
+    for (const objectInfoFieldName of fieldNames) {
+        const field = objectInfo.fields[objectInfoFieldName];
+        if (field.reference === true && field.relationshipName === fieldName) {
+            return objectInfoFieldName;
+        }
+    }
+}
+function buildFieldUnionArray(existingRecord, incomingRecord, objectInfo) {
+    const allFields = Array.from(new Set([...Object.keys(existingRecord.fields), ...Object.keys(incomingRecord.fields)]));
+    const fieldUnion = [];
+    allFields.forEach((fieldName) => {
+        const objectInfoField = objectInfo.fields[fieldName];
+        if (objectInfoField === undefined) {
+            // find the reference field for the spanning field
+            const referenceField = findReferenceFieldForSpanningField(fieldName, objectInfo);
+            if (referenceField !== undefined) {
+                fieldUnion.push(`${fieldName}.Id`);
+            }
+        }
+        else {
+            fieldUnion.push(fieldName);
+        }
+    });
+    return fieldUnion;
+}
+/**
+ * Merges (if possible) an incoming record from a priming session with an existing record in the durable store.
+ *
+ * IMPORTANT NOTE: this is not a suitable function to use for general merging of two DurableRecordRepresentation since it
+ * makes the assumption that the incoming record ONLY contains scalar field values and no spanning records. The same is not
+ * necessarily true for the existing record as it may have been populated in the cache outside of a priming session.
+ * This function should not be moved out of the priming module!
+ *
+ * @param existingRecord Existing record in the durable store
+ * @param incomingRecord Incoming record from the priming session
+ * @param objectInfo Object info for the incoming record type
+ * @returns Merge result describing the success or failure of the merge operation
+ */
+function mergeRecord(existingRecord, incomingRecord, objectInfo) {
+    // cache already contains everything incoming has
+    if (existingRecord.weakEtag >= incomingRecord.weakEtag &&
+        getMissingElementsFromSuperset(Object.keys(existingRecord.fields), Object.keys(incomingRecord.fields)).length === 0) {
+        return {
+            ok: true,
+            code: 'success',
+            needsWrite: false,
+            record: existingRecord,
+        };
+    }
+    // don't touch records that contain drafts
+    if (existingRecord.drafts !== undefined) {
+        return {
+            ok: false,
+            code: 'conflict-drafts',
+            hasDraft: true,
+            fieldUnion: buildFieldUnionArray(existingRecord, incomingRecord, objectInfo),
+        };
+    }
+    // Check if incoming record's Etag is equal to the existing one
+    if (existingRecord.weakEtag === incomingRecord.weakEtag) {
+        // If so, merge the fields and return the updated record
+        return {
+            ok: true,
+            needsWrite: true,
+            code: 'success',
+            record: {
+                ...existingRecord,
+                fields: {
+                    ...existingRecord.fields,
+                    ...incomingRecord.fields,
+                },
+                links: {
+                    ...existingRecord.links,
+                    ...incomingRecord.links,
+                },
+            },
+        };
+    }
+    else if (incomingRecord.weakEtag > existingRecord.weakEtag &&
+        getMissingElementsFromSuperset(Object.keys(incomingRecord.fields), Object.keys(existingRecord.fields)).length === 0) {
+        // If incoming record's Etag is higher and contains all the fields, overwrite the record
+        // NOTE: if existing record contains spanning records, this condition will never hit since incoming won't have those fields
+        return { ok: true, code: 'success', needsWrite: true, record: incomingRecord };
+    }
+    else {
+        const missingFields = getMissingElementsFromSuperset(Object.keys(incomingRecord.fields), Object.keys(existingRecord.fields));
+        // if the only missing fields are spanning fields and their corresponding lookup fields match, we can merge
+        // since none of the changed fields are part of the incoming record
+        if (missingFields.every((field) => {
+            const referenceFieldName = findReferenceFieldForSpanningField(field, objectInfo);
+            if (referenceFieldName !== undefined) {
+                return (incomingRecord.fields[referenceFieldName].value ===
+                    existingRecord.fields[referenceFieldName].value);
+            }
+            else {
+                return false;
+            }
+        })) {
+            return {
+                ok: true,
+                needsWrite: true,
+                code: 'success',
+                record: {
+                    // we span the existing record to maintain spanning references
+                    ...incomingRecord,
+                    fields: {
+                        ...existingRecord.fields,
+                        ...incomingRecord.fields,
+                    },
+                    links: {
+                        ...existingRecord.links,
+                        ...incomingRecord.links,
+                    },
+                },
+            };
+        }
+        // If Etags do not match and the incoming record does not contain all fields, re-request the record
+        return {
+            ok: false,
+            code: 'conflict-missing-fields',
+            fieldUnion: buildFieldUnionArray(existingRecord, incomingRecord, objectInfo),
+            hasDraft: false,
+        };
+    }
+}
+
+const CONFLICT_POOL_SIZE = 5;
+/**
+ * A pool of workers that resolve conflicts between incoming records and records in the store.
+ */
+class ConflictPool {
+    constructor(store, objectInfoLoader) {
+        this.store = store;
+        this.objectInfoLoader = objectInfoLoader;
+        this.pool = new AsyncWorkerPool(CONFLICT_POOL_SIZE);
+    }
+    enqueueConflictedRecords(records, abortController) {
+        return this.pool.push({
+            workFn: () => this.resolveConflicts(records, abortController),
+        });
+    }
+    async resolveConflicts(incomingRecords, abortController) {
+        const result = {
+            additionalWork: { type: 'record-fields', records: {} },
+            recordsToWrite: [],
+            resolvedRecords: [],
+            recordsNeedingRefetch: new Map(),
+            errors: [],
+        };
+        const ids = [];
+        const trackedFieldsByType = new Map();
+        const apiNames = new Set();
+        incomingRecords.forEach((record) => {
+            ids.push(record.id);
+            apiNames.add(record.apiName);
+        });
+        const existingRecords = await this.store.readRecords(ids);
+        if (abortController.aborted) {
+            return result;
+        }
+        const objectInfos = await this.objectInfoLoader.getObjectInfos(Array.from(apiNames));
+        if (abortController.aborted) {
+            return result;
+        }
+        const existingRecordsById = new Map(existingRecords.map((record) => [record.record.id, record]));
+        for (const incomingRecord of incomingRecords) {
+            const existingDurableRecordRepresentation = existingRecordsById.get(incomingRecord.id);
+            const objectInfo = objectInfos[incomingRecord.apiName];
+            if (existingDurableRecordRepresentation === undefined) {
+                // this shouldn't happen but if it does, we should write the incoming record since there's nothing to merge
+                result.recordsToWrite.push(incomingRecord);
+                continue;
+            }
+            if (objectInfo === undefined) {
+                // object infos are a prerequisite for priming so if we don't have one, we can't do anything
+                result.errors.push({ id: incomingRecord.id, reason: 'object-info-missing' });
+                continue;
+            }
+            const existingRecord = existingDurableRecordRepresentation.record;
+            const mergedRecordResult = mergeRecord(existingRecord, incomingRecord, objectInfo);
+            if (mergedRecordResult.ok) {
+                if (mergedRecordResult.needsWrite) {
+                    result.recordsToWrite.push(mergedRecordResult.record);
+                }
+                else {
+                    result.resolvedRecords.push(mergedRecordResult.record.id);
+                }
+                continue;
+            }
+            else {
+                const { code } = mergedRecordResult;
+                const isConflict = code === 'conflict-drafts' ||
+                    code === 'conflict-spanning-record' ||
+                    code === 'conflict-missing-fields';
+                if (isConflict) {
+                    let trackedFields = trackedFieldsByType.get(incomingRecord.apiName);
+                    if (trackedFields === undefined) {
+                        trackedFields = new Set();
+                        trackedFieldsByType.set(incomingRecord.apiName, trackedFields);
+                    }
+                    mergedRecordResult.fieldUnion.forEach((field) => trackedFields.add(field));
+                    if (code === 'conflict-missing-fields') {
+                        const additionalWorkForType = result.additionalWork.records[incomingRecord.apiName];
+                        if (additionalWorkForType === undefined) {
+                            result.additionalWork.records[incomingRecord.apiName] = {
+                                ids: [incomingRecord.id],
+                                fields: Array.from(trackedFields),
+                            };
+                        }
+                        else {
+                            additionalWorkForType.ids.push(incomingRecord.id);
+                            additionalWorkForType.fields = Array.from(trackedFields);
+                        }
+                    }
+                    else if (code === 'conflict-drafts' || code === 'conflict-spanning-record') {
+                        const recordByType = result.recordsNeedingRefetch.get(incomingRecord.apiName);
+                        if (recordByType === undefined) {
+                            result.recordsNeedingRefetch.set(incomingRecord.apiName, {
+                                ids: [incomingRecord.id],
+                                fields: Array.from(trackedFields),
+                            });
+                        }
+                        else {
+                            recordByType.ids.push(incomingRecord.id);
+                            recordByType.fields = Array.from(trackedFields);
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}
+
 const DEFAULT_BATCH_SIZE = 500;
 const DEFAULT_CONCURRENCY = 6;
 const DEFAULT_GQL_QUERY_BATCH_SIZE = 5;
@@ -59054,8 +59295,10 @@ class PrimingSession extends EventEmitter {
         this.recordLoader = config.recordLoader;
         this.recordIngestor = config.recordIngestor;
         this.objectInfoLoader = config.objectInfoLoader;
+        this.ldsRecordRefresher = config.ldsRecordRefresher;
         this.networkWorkerPool = new AsyncWorkerPool(this.concurrency);
         this.useBatchGQL = ldsPrimingGraphqlBatch.isOpen({ fallback: false });
+        this.conflictPool = new ConflictPool(config.store, this.objectInfoLoader);
     }
     // function that enqueues priming work
     async enqueue(work) {
@@ -59180,7 +59423,9 @@ class PrimingSession extends EventEmitter {
         const { records } = result;
         const beforeWrite = Date.now();
         // dispatch the write but DO NOT wait on it to unblock the network pool
-        this.recordIngestor.insertRecords(records).then(({ written, conflicted, errors }) => {
+        this.recordIngestor
+            .insertRecords(records, false)
+            .then(({ written, conflicted, errors }) => {
             this.emit('batch-written', {
                 written,
                 conflicted,
@@ -59203,16 +59448,69 @@ class PrimingSession extends EventEmitter {
             if (written.length > 0) {
                 this.emit('primed', Array.from(written));
             }
-            // TODO [W-12436213]: implement conflict resolution
+            // if any records could not be written to the store because there were conflicts, handle the conflicts
+            if (conflicted.length > 0) {
+                this.handleWriteConflicts(records, conflicted, abortController);
+            }
+        });
+    }
+    async handleWriteConflicts(records, conflicted, abortController) {
+        const result = await this.conflictPool.enqueueConflictedRecords(records.filter((x) => conflicted.includes(x.id)), abortController);
+        if (abortController.aborted) {
+            return;
+        }
+        if (Object.keys(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);
+        }
+        if (result.resolvedRecords.length > 0) {
+            this.emit('conflict', {
+                ids: result.resolvedRecords,
+                resolution: 'priming-merge',
+            });
+            this.emit('primed', result.resolvedRecords);
+        }
+        if (result.recordsToWrite.length > 0) {
+            const { written, errors, conflicted } = await this.recordIngestor.insertRecords(result.recordsToWrite, true);
+            if (written.length > 0) {
+                const ids = Array.from(written);
+                this.emit('conflict', { ids, resolution: 'priming-merge' });
+                this.emit('primed', ids);
+            }
+            if (errors.length > 0) {
+                errors.forEach(({ ids, message }) => {
+                    this.emit('error', {
+                        ids,
+                        code: 'unknown',
+                        message: message,
+                    });
+                });
+            }
             if (conflicted.length > 0) {
-                // for now emit conlicts as errors
                 this.emit('error', {
-                    ids: Array.from(conflicted),
+                    ids: conflicted,
                     code: 'unknown',
-                    message: 'conflict when persisting record',
+                    message: 'unexpected write conflict',
                 });
             }
-        });
+        }
+        if (result.recordsNeedingRefetch.size > 0) {
+            const { loaded, errored } = await this.ldsRecordRefresher.loadRecords(result.recordsNeedingRefetch);
+            if (loaded.length > 0) {
+                this.emit('conflict', { resolution: 'lds-refresh', ids: loaded });
+                this.emit('primed', loaded);
+            }
+            if (errored.length > 0) {
+                this.emit('error', {
+                    ids: errored,
+                    code: 'unknown',
+                    message: `could not resolve conflicts`,
+                });
+            }
+        }
     }
     async fetchMetadata(batches) {
         const apiNames = Array.from(batches.reduce((acc, x) => {
@@ -59451,6 +59749,9 @@ function instrumentPrimingSession(session) {
     });
     session.on('primed', ({ length }) => {
     });
+    session.on('conflict', ({ ids, resolution }) => {
+        reportPrimingConflict(resolution, ids.length);
+    });
     return session;
 }
 
@@ -59632,19 +59933,72 @@ function batchArray(arr, batchSize = BATCH_SIZE) {
     return batches;
 }
 
+/**
+ * A polyfill for Promise.allSettled
+ * @param promises An array of promises
+ * @returns the result of all the promises when they either fulfill or reject
+ */
+function allSettled(promises) {
+    let wrappedPromises = promises.map((p) => Promise.resolve(p).then((value) => ({ status: 'fulfilled', value }), (reason) => ({ status: 'rejected', reason })));
+    return Promise.all(wrappedPromises);
+}
+
+class LdsPrimingRecordRefresher {
+    constructor(getRecordsAdapter) {
+        this.getRecordsAdapter = getRecordsAdapter;
+    }
+    async loadRecords(records) {
+        const requestedRecords = new Set();
+        const promises = Array.from(records).flatMap(([_apiName, value]) => {
+            value.ids.forEach((id) => requestedRecords.add(id));
+            return Promise.resolve(this.getRecordsAdapter({
+                records: [
+                    {
+                        recordIds: value.ids,
+                        optionalFields: value.fields.map((f) => `${_apiName}.${f}`),
+                    },
+                ],
+            }));
+        });
+        const promiseResults = await allSettled(promises);
+        const loaded = [];
+        promiseResults.forEach((promiseResult) => {
+            if (promiseResult.status === 'fulfilled') {
+                const batchResultRepresenatation = promiseResult.value;
+                if (batchResultRepresenatation &&
+                    batchResultRepresenatation.state === 'Fulfilled') {
+                    batchResultRepresenatation.data.results.forEach((result) => {
+                        if (result.statusCode === 200) {
+                            const id = result.result.id;
+                            loaded.push(id);
+                            requestedRecords.delete(id);
+                        }
+                    });
+                }
+            }
+        });
+        // errored contains all the requestedRecords that weren't loaded
+        const errored = Array.from(requestedRecords);
+        return { loaded, errored };
+    }
+}
+
 function primingSessionFactory(config) {
     const { store, objectInfoService, getLuvio } = config;
     const networkAdapter = new NimbusPrimingNetworkAdapter();
     const recordLoader = new RecordLoaderGraphQL(networkAdapter);
-    const recordIngestor = new RecordIngestor(new SqlitePrimingStore(getLuvio, store), getLuvio);
+    const primingStore = new SqlitePrimingStore(getLuvio, store);
+    const recordIngestor = new RecordIngestor(primingStore, getLuvio);
     const session = new PrimingSession({
         recordLoader,
         recordIngestor,
+        store: primingStore,
         objectInfoLoader: {
             getObjectInfos: objectInfoService.getObjectInfos.bind(objectInfoService),
         },
         concurrency: config.concurrency,
         batchSize: config.batchSize,
+        ldsRecordRefresher: new LdsPrimingRecordRefresher(config.getRecords),
     });
     return instrumentPrimingSession(session);
 }
@@ -59658,6 +60012,7 @@ let lazyEnvironment;
 let lazyBaseDurableStore;
 let lazyNetworkAdapter;
 let lazyObjectInfoService;
+let lazyGetRecords;
 /**
  * This returns the LDS on Mobile Runtime singleton object.
  */
@@ -59728,6 +60083,7 @@ function getRuntime() {
         lazyLuvio = new Luvio(lazyEnvironment, {
             instrument: instrumentLuvio,
         });
+        lazyGetRecords = getRecordsAdapterFactory(lazyLuvio);
         // Currently instruments store runtime perf
         setupMobileInstrumentation();
         // If the inspection nimbus plugin is configured, inspection is enabled otherwise this is a no-op
@@ -59781,6 +60137,7 @@ function getRuntime() {
                 getLuvio: () => lazyLuvio,
                 concurrency: config.concurrency,
                 batchSize: config.batchSize,
+                getRecords: lazyGetRecords,
             });
         },
     };
@@ -59797,7 +60154,7 @@ register({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$1,
 });
-// version: 1.208.1-8f4c4550e
+// version: 1.210.0-b2655462f
 
 const { create: create$2, keys: keys$2 } = Object;
 const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -77140,7 +77497,7 @@ register({
     configuration: { ...configurationForGraphQLAdapters },
     instrument,
 });
-// version: 1.208.1-9aaa359ad
+// version: 1.210.0-2883d2f5f
 
 // On core the unstable adapters are re-exported with different names,
 
@@ -79387,7 +79744,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.208.1-9aaa359ad
+// version: 1.210.0-2883d2f5f
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -80054,26 +80411,51 @@ function createPrimingSession(config) {
     const { primingEventHandler, concurrency, batchSize } = config;
     const session = createPrimingSession({ concurrency, batchSize });
     if (primingEventHandler) {
-        const { onError, onPrimed } = primingEventHandler;
-        if (onError) {
-            session.on('error', onError.bind(primingEventHandler));
-        }
-        if (onPrimed) {
-            session.on('primed', onPrimed.bind(primingEventHandler));
-        }
-    }
+        addEventHandler(session, primingEventHandler);
+    }
+    const registerEventHandler = (handler) => {
+        // bind creates a new function and we need to retain reference to that function
+        // in order to be able to remove it
+        const boundCallbacks = {
+            onError: handler.onError ? handler.onError.bind(handler) : undefined,
+            onPrimed: handler.onPrimed ? handler.onPrimed.bind(handler) : undefined,
+        };
+        addEventHandler(session, boundCallbacks);
+        return () => {
+            removeEventHandler(session, boundCallbacks);
+        };
+    };
     return {
         enqueue: session.enqueue.bind(session),
         cancel: session.cancel.bind(session),
         on: session.on.bind(session),
         once: session.once.bind(session),
         off: session.off.bind(session),
+        registerEventHandler,
     };
 }
+function addEventHandler(session, handler) {
+    const { onError, onPrimed } = handler;
+    if (onError) {
+        session.on('error', onError);
+    }
+    if (onPrimed) {
+        session.on('primed', onPrimed);
+    }
+}
+function removeEventHandler(session, handler) {
+    const { onError, onPrimed } = handler;
+    if (onError) {
+        session.off('error', onError);
+    }
+    if (onPrimed) {
+        session.off('primed', onPrimed);
+    }
+}
 
 // LWR has a "setupLDS" bootstrap service/loader hook, we simulate this in
 const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, subscribeToAdapter };
-// version: 1.208.1-8f4c4550e
+// version: 1.210.0-b2655462f

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

@@ -1,10 +1,11 @@
+import type { PrimingSession } from '@salesforce/lds-priming';
 interface PrimingError {
     ids: string[];
     code: ErrorCode;
     message: string;
 }
 type ErrorCode = 'precondition-error' | 'not-found' | 'service-unavailable' | 'canceled' | 'unknown';
-interface PrimingEventHandler {
+export interface PrimingEventHandler {
     onError?: (error: PrimingError) => void;
     onPrimed?: (ids: string[]) => void;
 }
@@ -16,8 +17,9 @@ export interface PrimingSessionConfig {
 export declare function createPrimingSession(config: PrimingSessionConfig): {
     enqueue: (work: PrimingWork) => Promise<void>;
     cancel: () => void;
-    on: <K extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K]) => void) => import("@salesforce/lds-priming").PrimingSession;
-    once: <K_1 extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K_1, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K_1]) => void) => import("@salesforce/lds-priming").PrimingSession;
-    off: <K_2 extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K_2, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K_2]) => void) => import("@salesforce/lds-priming").PrimingSession;
+    on: <K extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K]) => void) => PrimingSession;
+    once: <K_1 extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K_1, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K_1]) => void) => PrimingSession;
+    off: <K_2 extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K_2, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K_2]) => void) => PrimingSession;
+    registerEventHandler: (handler: PrimingEventHandler) => () => void;
 };
 export {};

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

@@ -3868,7 +3868,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.208.1-8f4c4550e
+    // version: 1.210.0-b2655462f
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -15301,7 +15301,7 @@
         updateReferenceMapWithKnownKey(ast, luvioDocumentNode);
         return luvioDocumentNode;
     }
-    // version: 1.208.1-8f4c4550e
+    // version: 1.210.0-b2655462f
 
     function unwrap(data) {
         // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16224,7 +16224,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.208.1-8f4c4550e
+    // version: 1.210.0-b2655462f
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -43562,7 +43562,7 @@
         });
         throttle(60, 60000, createLDSAdapter(luvio, 'notifyListViewSummaryUpdateAvailable', notifyUpdateAvailableFactory));
     });
-    // version: 1.208.1-9aaa359ad
+    // version: 1.210.0-2883d2f5f
 
     var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -58072,6 +58072,8 @@
     }
     function reportPrimingError(errorType, recordCount) {
     }
+    function reportPrimingConflict(resolutionType, recordCount) {
+    }
 
     /**
      * HOF (high-order-function) that instruments any async operation.  If the operation
@@ -59047,6 +59049,245 @@
         return batches;
     }
 
+    function getMissingElementsFromSuperset(superset, subset) {
+        return subset.filter((val) => !superset.includes(val));
+    }
+    function findReferenceFieldForSpanningField(fieldName, objectInfo) {
+        const fieldNames = Object.keys(objectInfo.fields);
+        for (const objectInfoFieldName of fieldNames) {
+            const field = objectInfo.fields[objectInfoFieldName];
+            if (field.reference === true && field.relationshipName === fieldName) {
+                return objectInfoFieldName;
+            }
+        }
+    }
+    function buildFieldUnionArray(existingRecord, incomingRecord, objectInfo) {
+        const allFields = Array.from(new Set([...Object.keys(existingRecord.fields), ...Object.keys(incomingRecord.fields)]));
+        const fieldUnion = [];
+        allFields.forEach((fieldName) => {
+            const objectInfoField = objectInfo.fields[fieldName];
+            if (objectInfoField === undefined) {
+                // find the reference field for the spanning field
+                const referenceField = findReferenceFieldForSpanningField(fieldName, objectInfo);
+                if (referenceField !== undefined) {
+                    fieldUnion.push(`${fieldName}.Id`);
+                }
+            }
+            else {
+                fieldUnion.push(fieldName);
+            }
+        });
+        return fieldUnion;
+    }
+    /**
+     * Merges (if possible) an incoming record from a priming session with an existing record in the durable store.
+     *
+     * IMPORTANT NOTE: this is not a suitable function to use for general merging of two DurableRecordRepresentation since it
+     * makes the assumption that the incoming record ONLY contains scalar field values and no spanning records. The same is not
+     * necessarily true for the existing record as it may have been populated in the cache outside of a priming session.
+     * This function should not be moved out of the priming module!
+     *
+     * @param existingRecord Existing record in the durable store
+     * @param incomingRecord Incoming record from the priming session
+     * @param objectInfo Object info for the incoming record type
+     * @returns Merge result describing the success or failure of the merge operation
+     */
+    function mergeRecord(existingRecord, incomingRecord, objectInfo) {
+        // cache already contains everything incoming has
+        if (existingRecord.weakEtag >= incomingRecord.weakEtag &&
+            getMissingElementsFromSuperset(Object.keys(existingRecord.fields), Object.keys(incomingRecord.fields)).length === 0) {
+            return {
+                ok: true,
+                code: 'success',
+                needsWrite: false,
+                record: existingRecord,
+            };
+        }
+        // don't touch records that contain drafts
+        if (existingRecord.drafts !== undefined) {
+            return {
+                ok: false,
+                code: 'conflict-drafts',
+                hasDraft: true,
+                fieldUnion: buildFieldUnionArray(existingRecord, incomingRecord, objectInfo),
+            };
+        }
+        // Check if incoming record's Etag is equal to the existing one
+        if (existingRecord.weakEtag === incomingRecord.weakEtag) {
+            // If so, merge the fields and return the updated record
+            return {
+                ok: true,
+                needsWrite: true,
+                code: 'success',
+                record: {
+                    ...existingRecord,
+                    fields: {
+                        ...existingRecord.fields,
+                        ...incomingRecord.fields,
+                    },
+                    links: {
+                        ...existingRecord.links,
+                        ...incomingRecord.links,
+                    },
+                },
+            };
+        }
+        else if (incomingRecord.weakEtag > existingRecord.weakEtag &&
+            getMissingElementsFromSuperset(Object.keys(incomingRecord.fields), Object.keys(existingRecord.fields)).length === 0) {
+            // If incoming record's Etag is higher and contains all the fields, overwrite the record
+            // NOTE: if existing record contains spanning records, this condition will never hit since incoming won't have those fields
+            return { ok: true, code: 'success', needsWrite: true, record: incomingRecord };
+        }
+        else {
+            const missingFields = getMissingElementsFromSuperset(Object.keys(incomingRecord.fields), Object.keys(existingRecord.fields));
+            // if the only missing fields are spanning fields and their corresponding lookup fields match, we can merge
+            // since none of the changed fields are part of the incoming record
+            if (missingFields.every((field) => {
+                const referenceFieldName = findReferenceFieldForSpanningField(field, objectInfo);
+                if (referenceFieldName !== undefined) {
+                    return (incomingRecord.fields[referenceFieldName].value ===
+                        existingRecord.fields[referenceFieldName].value);
+                }
+                else {
+                    return false;
+                }
+            })) {
+                return {
+                    ok: true,
+                    needsWrite: true,
+                    code: 'success',
+                    record: {
+                        // we span the existing record to maintain spanning references
+                        ...incomingRecord,
+                        fields: {
+                            ...existingRecord.fields,
+                            ...incomingRecord.fields,
+                        },
+                        links: {
+                            ...existingRecord.links,
+                            ...incomingRecord.links,
+                        },
+                    },
+                };
+            }
+            // If Etags do not match and the incoming record does not contain all fields, re-request the record
+            return {
+                ok: false,
+                code: 'conflict-missing-fields',
+                fieldUnion: buildFieldUnionArray(existingRecord, incomingRecord, objectInfo),
+                hasDraft: false,
+            };
+        }
+    }
+
+    const CONFLICT_POOL_SIZE = 5;
+    /**
+     * A pool of workers that resolve conflicts between incoming records and records in the store.
+     */
+    class ConflictPool {
+        constructor(store, objectInfoLoader) {
+            this.store = store;
+            this.objectInfoLoader = objectInfoLoader;
+            this.pool = new AsyncWorkerPool(CONFLICT_POOL_SIZE);
+        }
+        enqueueConflictedRecords(records, abortController) {
+            return this.pool.push({
+                workFn: () => this.resolveConflicts(records, abortController),
+            });
+        }
+        async resolveConflicts(incomingRecords, abortController) {
+            const result = {
+                additionalWork: { type: 'record-fields', records: {} },
+                recordsToWrite: [],
+                resolvedRecords: [],
+                recordsNeedingRefetch: new Map(),
+                errors: [],
+            };
+            const ids = [];
+            const trackedFieldsByType = new Map();
+            const apiNames = new Set();
+            incomingRecords.forEach((record) => {
+                ids.push(record.id);
+                apiNames.add(record.apiName);
+            });
+            const existingRecords = await this.store.readRecords(ids);
+            if (abortController.aborted) {
+                return result;
+            }
+            const objectInfos = await this.objectInfoLoader.getObjectInfos(Array.from(apiNames));
+            if (abortController.aborted) {
+                return result;
+            }
+            const existingRecordsById = new Map(existingRecords.map((record) => [record.record.id, record]));
+            for (const incomingRecord of incomingRecords) {
+                const existingDurableRecordRepresentation = existingRecordsById.get(incomingRecord.id);
+                const objectInfo = objectInfos[incomingRecord.apiName];
+                if (existingDurableRecordRepresentation === undefined) {
+                    // this shouldn't happen but if it does, we should write the incoming record since there's nothing to merge
+                    result.recordsToWrite.push(incomingRecord);
+                    continue;
+                }
+                if (objectInfo === undefined) {
+                    // object infos are a prerequisite for priming so if we don't have one, we can't do anything
+                    result.errors.push({ id: incomingRecord.id, reason: 'object-info-missing' });
+                    continue;
+                }
+                const existingRecord = existingDurableRecordRepresentation.record;
+                const mergedRecordResult = mergeRecord(existingRecord, incomingRecord, objectInfo);
+                if (mergedRecordResult.ok) {
+                    if (mergedRecordResult.needsWrite) {
+                        result.recordsToWrite.push(mergedRecordResult.record);
+                    }
+                    else {
+                        result.resolvedRecords.push(mergedRecordResult.record.id);
+                    }
+                    continue;
+                }
+                else {
+                    const { code } = mergedRecordResult;
+                    const isConflict = code === 'conflict-drafts' ||
+                        code === 'conflict-spanning-record' ||
+                        code === 'conflict-missing-fields';
+                    if (isConflict) {
+                        let trackedFields = trackedFieldsByType.get(incomingRecord.apiName);
+                        if (trackedFields === undefined) {
+                            trackedFields = new Set();
+                            trackedFieldsByType.set(incomingRecord.apiName, trackedFields);
+                        }
+                        mergedRecordResult.fieldUnion.forEach((field) => trackedFields.add(field));
+                        if (code === 'conflict-missing-fields') {
+                            const additionalWorkForType = result.additionalWork.records[incomingRecord.apiName];
+                            if (additionalWorkForType === undefined) {
+                                result.additionalWork.records[incomingRecord.apiName] = {
+                                    ids: [incomingRecord.id],
+                                    fields: Array.from(trackedFields),
+                                };
+                            }
+                            else {
+                                additionalWorkForType.ids.push(incomingRecord.id);
+                                additionalWorkForType.fields = Array.from(trackedFields);
+                            }
+                        }
+                        else if (code === 'conflict-drafts' || code === 'conflict-spanning-record') {
+                            const recordByType = result.recordsNeedingRefetch.get(incomingRecord.apiName);
+                            if (recordByType === undefined) {
+                                result.recordsNeedingRefetch.set(incomingRecord.apiName, {
+                                    ids: [incomingRecord.id],
+                                    fields: Array.from(trackedFields),
+                                });
+                            }
+                            else {
+                                recordByType.ids.push(incomingRecord.id);
+                                recordByType.fields = Array.from(trackedFields);
+                            }
+                        }
+                    }
+                }
+            }
+            return result;
+        }
+    }
+
     const DEFAULT_BATCH_SIZE = 500;
     const DEFAULT_CONCURRENCY = 6;
     const DEFAULT_GQL_QUERY_BATCH_SIZE = 5;
@@ -59060,8 +59301,10 @@
             this.recordLoader = config.recordLoader;
             this.recordIngestor = config.recordIngestor;
             this.objectInfoLoader = config.objectInfoLoader;
+            this.ldsRecordRefresher = config.ldsRecordRefresher;
             this.networkWorkerPool = new AsyncWorkerPool(this.concurrency);
             this.useBatchGQL = ldsPrimingGraphqlBatch.isOpen({ fallback: false });
+            this.conflictPool = new ConflictPool(config.store, this.objectInfoLoader);
         }
         // function that enqueues priming work
         async enqueue(work) {
@@ -59186,7 +59429,9 @@
             const { records } = result;
             const beforeWrite = Date.now();
             // dispatch the write but DO NOT wait on it to unblock the network pool
-            this.recordIngestor.insertRecords(records).then(({ written, conflicted, errors }) => {
+            this.recordIngestor
+                .insertRecords(records, false)
+                .then(({ written, conflicted, errors }) => {
                 this.emit('batch-written', {
                     written,
                     conflicted,
@@ -59209,16 +59454,69 @@
                 if (written.length > 0) {
                     this.emit('primed', Array.from(written));
                 }
-                // TODO [W-12436213]: implement conflict resolution
+                // if any records could not be written to the store because there were conflicts, handle the conflicts
+                if (conflicted.length > 0) {
+                    this.handleWriteConflicts(records, conflicted, abortController);
+                }
+            });
+        }
+        async handleWriteConflicts(records, conflicted, abortController) {
+            const result = await this.conflictPool.enqueueConflictedRecords(records.filter((x) => conflicted.includes(x.id)), abortController);
+            if (abortController.aborted) {
+                return;
+            }
+            if (Object.keys(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);
+            }
+            if (result.resolvedRecords.length > 0) {
+                this.emit('conflict', {
+                    ids: result.resolvedRecords,
+                    resolution: 'priming-merge',
+                });
+                this.emit('primed', result.resolvedRecords);
+            }
+            if (result.recordsToWrite.length > 0) {
+                const { written, errors, conflicted } = await this.recordIngestor.insertRecords(result.recordsToWrite, true);
+                if (written.length > 0) {
+                    const ids = Array.from(written);
+                    this.emit('conflict', { ids, resolution: 'priming-merge' });
+                    this.emit('primed', ids);
+                }
+                if (errors.length > 0) {
+                    errors.forEach(({ ids, message }) => {
+                        this.emit('error', {
+                            ids,
+                            code: 'unknown',
+                            message: message,
+                        });
+                    });
+                }
                 if (conflicted.length > 0) {
-                    // for now emit conlicts as errors
                     this.emit('error', {
-                        ids: Array.from(conflicted),
+                        ids: conflicted,
                         code: 'unknown',
-                        message: 'conflict when persisting record',
+                        message: 'unexpected write conflict',
                     });
                 }
-            });
+            }
+            if (result.recordsNeedingRefetch.size > 0) {
+                const { loaded, errored } = await this.ldsRecordRefresher.loadRecords(result.recordsNeedingRefetch);
+                if (loaded.length > 0) {
+                    this.emit('conflict', { resolution: 'lds-refresh', ids: loaded });
+                    this.emit('primed', loaded);
+                }
+                if (errored.length > 0) {
+                    this.emit('error', {
+                        ids: errored,
+                        code: 'unknown',
+                        message: `could not resolve conflicts`,
+                    });
+                }
+            }
         }
         async fetchMetadata(batches) {
             const apiNames = Array.from(batches.reduce((acc, x) => {
@@ -59457,6 +59755,9 @@
         });
         session.on('primed', ({ length }) => {
         });
+        session.on('conflict', ({ ids, resolution }) => {
+            reportPrimingConflict(resolution, ids.length);
+        });
         return session;
     }
 
@@ -59638,19 +59939,72 @@
         return batches;
     }
 
+    /**
+     * A polyfill for Promise.allSettled
+     * @param promises An array of promises
+     * @returns the result of all the promises when they either fulfill or reject
+     */
+    function allSettled(promises) {
+        let wrappedPromises = promises.map((p) => Promise.resolve(p).then((value) => ({ status: 'fulfilled', value }), (reason) => ({ status: 'rejected', reason })));
+        return Promise.all(wrappedPromises);
+    }
+
+    class LdsPrimingRecordRefresher {
+        constructor(getRecordsAdapter) {
+            this.getRecordsAdapter = getRecordsAdapter;
+        }
+        async loadRecords(records) {
+            const requestedRecords = new Set();
+            const promises = Array.from(records).flatMap(([_apiName, value]) => {
+                value.ids.forEach((id) => requestedRecords.add(id));
+                return Promise.resolve(this.getRecordsAdapter({
+                    records: [
+                        {
+                            recordIds: value.ids,
+                            optionalFields: value.fields.map((f) => `${_apiName}.${f}`),
+                        },
+                    ],
+                }));
+            });
+            const promiseResults = await allSettled(promises);
+            const loaded = [];
+            promiseResults.forEach((promiseResult) => {
+                if (promiseResult.status === 'fulfilled') {
+                    const batchResultRepresenatation = promiseResult.value;
+                    if (batchResultRepresenatation &&
+                        batchResultRepresenatation.state === 'Fulfilled') {
+                        batchResultRepresenatation.data.results.forEach((result) => {
+                            if (result.statusCode === 200) {
+                                const id = result.result.id;
+                                loaded.push(id);
+                                requestedRecords.delete(id);
+                            }
+                        });
+                    }
+                }
+            });
+            // errored contains all the requestedRecords that weren't loaded
+            const errored = Array.from(requestedRecords);
+            return { loaded, errored };
+        }
+    }
+
     function primingSessionFactory(config) {
         const { store, objectInfoService, getLuvio } = config;
         const networkAdapter = new NimbusPrimingNetworkAdapter();
         const recordLoader = new RecordLoaderGraphQL(networkAdapter);
-        const recordIngestor = new RecordIngestor(new SqlitePrimingStore(getLuvio, store), getLuvio);
+        const primingStore = new SqlitePrimingStore(getLuvio, store);
+        const recordIngestor = new RecordIngestor(primingStore, getLuvio);
         const session = new PrimingSession({
             recordLoader,
             recordIngestor,
+            store: primingStore,
             objectInfoLoader: {
                 getObjectInfos: objectInfoService.getObjectInfos.bind(objectInfoService),
             },
             concurrency: config.concurrency,
             batchSize: config.batchSize,
+            ldsRecordRefresher: new LdsPrimingRecordRefresher(config.getRecords),
         });
         return instrumentPrimingSession(session);
     }
@@ -59664,6 +60018,7 @@
     let lazyBaseDurableStore;
     let lazyNetworkAdapter;
     let lazyObjectInfoService;
+    let lazyGetRecords;
     /**
      * This returns the LDS on Mobile Runtime singleton object.
      */
@@ -59734,6 +60089,7 @@
             lazyLuvio = new Luvio(lazyEnvironment, {
                 instrument: instrumentLuvio,
             });
+            lazyGetRecords = getRecordsAdapterFactory(lazyLuvio);
             // Currently instruments store runtime perf
             setupMobileInstrumentation();
             // If the inspection nimbus plugin is configured, inspection is enabled otherwise this is a no-op
@@ -59787,6 +60143,7 @@
                     getLuvio: () => lazyLuvio,
                     concurrency: config.concurrency,
                     batchSize: config.batchSize,
+                    getRecords: lazyGetRecords,
                 });
             },
         };
@@ -59803,7 +60160,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$1,
     });
-    // version: 1.208.1-8f4c4550e
+    // version: 1.210.0-b2655462f
 
     const { create: create$2, keys: keys$2 } = Object;
     const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -77146,7 +77503,7 @@
         configuration: { ...configurationForGraphQLAdapters },
         instrument,
     });
-    // version: 1.208.1-9aaa359ad
+    // version: 1.210.0-2883d2f5f
 
     // On core the unstable adapters are re-exported with different names,
 
@@ -79393,7 +79750,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.208.1-9aaa359ad
+    // version: 1.210.0-2883d2f5f
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -80060,22 +80417,47 @@
         const { primingEventHandler, concurrency, batchSize } = config;
         const session = createPrimingSession({ concurrency, batchSize });
         if (primingEventHandler) {
-            const { onError, onPrimed } = primingEventHandler;
-            if (onError) {
-                session.on('error', onError.bind(primingEventHandler));
-            }
-            if (onPrimed) {
-                session.on('primed', onPrimed.bind(primingEventHandler));
-            }
-        }
+            addEventHandler(session, primingEventHandler);
+        }
+        const registerEventHandler = (handler) => {
+            // bind creates a new function and we need to retain reference to that function
+            // in order to be able to remove it
+            const boundCallbacks = {
+                onError: handler.onError ? handler.onError.bind(handler) : undefined,
+                onPrimed: handler.onPrimed ? handler.onPrimed.bind(handler) : undefined,
+            };
+            addEventHandler(session, boundCallbacks);
+            return () => {
+                removeEventHandler(session, boundCallbacks);
+            };
+        };
         return {
             enqueue: session.enqueue.bind(session),
             cancel: session.cancel.bind(session),
             on: session.on.bind(session),
             once: session.once.bind(session),
             off: session.off.bind(session),
+            registerEventHandler,
         };
     }
+    function addEventHandler(session, handler) {
+        const { onError, onPrimed } = handler;
+        if (onError) {
+            session.on('error', onError);
+        }
+        if (onPrimed) {
+            session.on('primed', onPrimed);
+        }
+    }
+    function removeEventHandler(session, handler) {
+        const { onError, onPrimed } = handler;
+        if (onError) {
+            session.off('error', onError);
+        }
+        if (onPrimed) {
+            session.off('primed', onPrimed);
+        }
+    }
 
     // LWR has a "setupLDS" bootstrap service/loader hook, we simulate this in
     const { luvio } = getRuntime();
@@ -80099,4 +80481,4 @@
     Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-// version: 1.208.1-8f4c4550e
+// version: 1.210.0-b2655462f

package/dist/standalone/umd/types/primingApi.d.ts

@@ -1,10 +1,11 @@
+import type { PrimingSession } from '@salesforce/lds-priming';
 interface PrimingError {
     ids: string[];
     code: ErrorCode;
     message: string;
 }
 type ErrorCode = 'precondition-error' | 'not-found' | 'service-unavailable' | 'canceled' | 'unknown';
-interface PrimingEventHandler {
+export interface PrimingEventHandler {
     onError?: (error: PrimingError) => void;
     onPrimed?: (ids: string[]) => void;
 }
@@ -16,8 +17,9 @@ export interface PrimingSessionConfig {
 export declare function createPrimingSession(config: PrimingSessionConfig): {
     enqueue: (work: PrimingWork) => Promise<void>;
     cancel: () => void;
-    on: <K extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K]) => void) => import("@salesforce/lds-priming").PrimingSession;
-    once: <K_1 extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K_1, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K_1]) => void) => import("@salesforce/lds-priming").PrimingSession;
-    off: <K_2 extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K_2, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K_2]) => void) => import("@salesforce/lds-priming").PrimingSession;
+    on: <K extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K]) => void) => PrimingSession;
+    once: <K_1 extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K_1, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K_1]) => void) => PrimingSession;
+    off: <K_2 extends keyof import("@salesforce/lds-priming").PrimingEvents>(eventName: K_2, callback: (payload: import("@salesforce/lds-priming").PrimingEvents[K_2]) => void) => PrimingSession;
+    registerEventHandler: (handler: PrimingEventHandler) => () => void;
 };
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-worker-api",
-    "version": "1.208.1",
+    "version": "1.210.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "",
     "main": "dist/standalone/es/lds-worker-api.js",