@salesforce/lds-ads-bridge 1.432.0 → 1.434.0

package/dist/ads-bridge-perf.js

@@ -483,7 +483,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.432.0-a57c62b660
+// version: 1.434.0-d8deb0d4ea
 
 /**
  * Returns true if the value acts like a Promise, i.e. has a "then" function,
@@ -4459,28 +4459,23 @@ let configurableCreateContentVersion = new Configurable();
  * Depth to which tracked fields will be added to a request that results from a cache miss.
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMiss = 5;
+let trackedFieldDepthOnCacheMiss = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a merge conflict
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMergeConflict = 5;
+let trackedFieldDepthOnCacheMergeConflict = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a notify change invocation by the consumer
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnNotifyChange = 5;
-/**
- * Determines if we will only fetch the 'Id' field for the leaf relationship record
- * @defaultValue 'false', replicates the current behavior and fetches all fields in the store for the leaf relationship record
- */
-let trackedFieldLeafNodeIdAndNameOnly = false;
+let trackedFieldDepthOnNotifyChange = 1;
 /**
  * One store enabled Get Object Info adapter
  */
@@ -4577,12 +4572,6 @@ const configurationForRestAdapters = {
     getTrackedFieldDepthOnNotifyChange: function () {
         return trackedFieldDepthOnNotifyChange;
     },
-    setTrackedFieldLeafNodeIdAndNameOnly: function (trackedFieldLeafNodeIdAndNameOnlyParam) {
-        trackedFieldLeafNodeIdAndNameOnly = trackedFieldLeafNodeIdAndNameOnlyParam;
-    },
-    getTrackedFieldLeafNodeIdAndNameOnly: function () {
-        return trackedFieldLeafNodeIdAndNameOnly;
-    },
     setRecordRepresentationIngestionOverride: function (ingest) {
         recordRepresentationIngestionOverride = ingest;
     },
@@ -6171,6 +6160,9 @@ function buildSelectionFromFields(fields, optionalFields = []) {
     return createRecordSelection(convertRecordFieldsArrayToTrie(fields, optionalFields));
 }
 
+// Unused suffixes, but leaving in as comments to avoid eslint errors
+// const CUSTOM_API_NAME_SUFFIX = '__c';
+// const DMO_API_NAME_SUFFIX = '__dlm';
 const CUSTOM_EXTERNAL_OBJECT_FIELD_SUFFIX = '__x';
 const RECORD_REPRESENTATION_ERROR_VERSION = 'RECORD_REPRESENTATION_ERROR_VERSION_1';
 const RECORD_REPRESENTATION_ERROR_STORE_METADATA_PARAMS = {
@@ -6197,7 +6189,7 @@ function addScalarField(current, leafNodeFieldKey) {
     }
 }
 function extractTrackedFieldsToTrie(recordId, node, root, config, visitedRecordIds = {}, depth = 0) {
-    var _a, _b;
+    var _a;
     // Filter Error and null nodes
     if (!isGraphNode$1(node)) {
         return;
@@ -6235,13 +6227,11 @@ function extractTrackedFieldsToTrie(recordId, node, root, config, visitedRecordI
             if (!isGraphNode$1(field)) {
                 continue;
             }
-            const { maxDepth, onlyFetchLeafNodeIdAndName } = config;
+            const { maxDepth } = config;
             if (field.isScalar('value') === false && !Array.isArray((_a = field.data) === null || _a === void 0 ? void 0 : _a.value)) {
                 if (depth + 1 > maxDepth) {
-                    if (onlyFetchLeafNodeIdAndName === true) {
-                        addScalarFieldId(current);
-                        addScalarFieldName(current);
-                    }
+                    addScalarFieldId(current);
+                    addScalarFieldName(current);
                     continue;
                 }
                 const spanningLink = field.link('value');
@@ -6263,19 +6253,10 @@ function extractTrackedFieldsToTrie(recordId, node, root, config, visitedRecordI
                 current.children[key] = next;
             }
             else {
-                // Skip the field, if its value is null at the max level depth.
-                // Ideally, it should only skip relationship field. However,
-                // on the client, there is not a reliable way to determine the
-                // the field type.
                 if (depth === maxDepth) {
-                    if (onlyFetchLeafNodeIdAndName === true) {
-                        addScalarFieldId(current);
-                        addScalarFieldName(current);
-                        continue;
-                    }
-                    if (field.scalar('value') === null && !Array.isArray((_b = field.data) === null || _b === void 0 ? void 0 : _b.value)) {
-                        continue;
-                    }
+                    addScalarFieldId(current);
+                    addScalarFieldName(current);
+                    continue;
                 }
                 const state = fieldValueRep.linkData();
                 if (state !== undefined) {
@@ -6610,7 +6591,6 @@ function mergeRecordConflict(luvio, incoming, existing, recordConflictMap) {
     };
     const trackedFieldsConfig = {
         maxDepth: configurationForRestAdapters.getTrackedFieldDepthOnCacheMergeConflict(),
-        onlyFetchLeafNodeIdAndName: configurationForRestAdapters.getTrackedFieldLeafNodeIdAndNameOnly(),
     };
     extractTrackedFieldsToTrie(recordKey, incomingNode, incomingTrackedFieldsTrieRoot, trackedFieldsConfig);
     extractTrackedFieldsToTrie(recordKey, existingNode, existingTrackedFieldsTrieRoot, trackedFieldsConfig);
@@ -7048,7 +7028,6 @@ function prepareRequest$7(luvio, config) {
     const key = keyBuilder$3T(luvio, createResourceParams$15(config));
     const allTrackedFields = getTrackedFields(key, luvio.getNode(key), {
         maxDepth: configurationForRestAdapters.getTrackedFieldDepthOnCacheMiss(),
-        onlyFetchLeafNodeIdAndName: configurationForRestAdapters.getTrackedFieldLeafNodeIdAndNameOnly(),
     }, config.optionalFields);
     const optionalFields = fields === undefined ? allTrackedFields : difference(allTrackedFields, fields);
     const resourceParams = createResourceParams$15({
@@ -7141,7 +7120,6 @@ function ingestSuccessChildResourceParams$9(luvio, childResourceParamsArray, chi
             };
             const childTrackedFields = getTrackedFields(childKey, luvio.getNode(childKey), {
                 maxDepth: configurationForRestAdapters.getTrackedFieldDepthOnCacheMiss(),
-                onlyFetchLeafNodeIdAndName: configurationForRestAdapters.getTrackedFieldLeafNodeIdAndNameOnly(),
             }, childResourceParams.queryParams.optionalFields);
             const childSnapshot = ingestSuccess$X(luvio, {
                 recordId: childResourceParams.urlParams.recordId,
@@ -7900,6 +7878,9 @@ function isSpanningRecord(fieldValue) {
 function isStoreKeyRecordId(key) {
     return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1;
 }
+function isStoreKeyRecordField(key) {
+    return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) > -1;
+}
 /**
  * Returns a shallow copy of a record with its field values if it is a scalar and a reference and a
  * a RecordRepresentation with no field if the value if a spanning record.
@@ -8194,6 +8175,33 @@ class AdsBridge {
             this.isRecordEmitLocked = false;
         }
     }
+    filterAndSynthesizeBaseIds(updatedEntries) {
+        // Collect base record IDs that are directly present in the entries.
+        const directBaseIds = new Set();
+        for (let i = 0; i < updatedEntries.length; i++) {
+            if (isStoreKeyRecordId(updatedEntries[i].id)) {
+                directBaseIds.add(updatedEntries[i].id);
+            }
+        }
+        // For field entries whose base record ID has no direct entry, synthesize one.
+        const syntheticBaseIds = new Set();
+        for (let i = 0; i < updatedEntries.length; i++) {
+            if (isStoreKeyRecordField(updatedEntries[i].id)) {
+                const baseId = updatedEntries[i].id.split(RECORD_FIELDS_KEY_JUNCTION)[0];
+                if (!directBaseIds.has(baseId)) {
+                    syntheticBaseIds.add(baseId);
+                }
+            }
+        }
+        // Exclude all the store record ids not matching with the record id pattern.
+        // Note: FieldValueRepresentation have the same prefix than RecordRepresentation so we
+        // need to filter them out.
+        const filteredUpdatedEntries = updatedEntries.filter((entry) => isStoreKeyRecordId(entry.id));
+        syntheticBaseIds.forEach((baseId) => {
+            push.call(filteredUpdatedEntries, { id: baseId });
+        });
+        return filteredUpdatedEntries;
+    }
     /**
      * This method retrieves queries the store with with passed record ids to retrieve their
      * associated records and object info. Note that the passed ids are not Salesforce record id
@@ -8204,14 +8212,10 @@ class AdsBridge {
         let shouldEmit = false;
         const adsRecordMap = {};
         const adsObjectMap = {};
-        for (let i = 0; i < updatedEntries.length; i++) {
-            const storeRecordId = updatedEntries[i].id;
-            // Exclude all the store record ids not matching with the record id pattern.
-            // Note: FieldValueRepresentation have the same prefix than RecordRepresentation so we
-            // need to filter them out.
-            if (!isStoreKeyRecordId(storeRecordId)) {
-                continue;
-            }
+        // Context for change: W-21715343
+        const filteredUpdatedEntries = this.filterAndSynthesizeBaseIds(updatedEntries);
+        for (let i = 0; i < filteredUpdatedEntries.length; i++) {
+            const storeRecordId = filteredUpdatedEntries[i].id;
             const record = this.recordRepresentationIngestOverride !== undefined
                 ? getShallowRecordDenormalized(luvio, storeRecordId)
                 : getShallowRecord(luvio, storeRecordId);

package/dist/adsBridge.js

@@ -58,6 +58,9 @@ function isSpanningRecord(fieldValue) {
 function isStoreKeyRecordId(key) {
     return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1;
 }
+function isStoreKeyRecordField(key) {
+    return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) > -1;
+}
 /**
  * Returns a shallow copy of a record with its field values if it is a scalar and a reference and a
  * a RecordRepresentation with no field if the value if a spanning record.
@@ -356,6 +359,33 @@ class AdsBridge {
             this.isRecordEmitLocked = false;
         }
     }
+    filterAndSynthesizeBaseIds(updatedEntries) {
+        // Collect base record IDs that are directly present in the entries.
+        const directBaseIds = new Set();
+        for (let i = 0; i < updatedEntries.length; i++) {
+            if (isStoreKeyRecordId(updatedEntries[i].id)) {
+                directBaseIds.add(updatedEntries[i].id);
+            }
+        }
+        // For field entries whose base record ID has no direct entry, synthesize one.
+        const syntheticBaseIds = new Set();
+        for (let i = 0; i < updatedEntries.length; i++) {
+            if (isStoreKeyRecordField(updatedEntries[i].id)) {
+                const baseId = updatedEntries[i].id.split(RECORD_FIELDS_KEY_JUNCTION)[0];
+                if (!directBaseIds.has(baseId)) {
+                    syntheticBaseIds.add(baseId);
+                }
+            }
+        }
+        // Exclude all the store record ids not matching with the record id pattern.
+        // Note: FieldValueRepresentation have the same prefix than RecordRepresentation so we
+        // need to filter them out.
+        const filteredUpdatedEntries = updatedEntries.filter((entry) => isStoreKeyRecordId(entry.id));
+        syntheticBaseIds.forEach((baseId) => {
+            push.call(filteredUpdatedEntries, { id: baseId });
+        });
+        return filteredUpdatedEntries;
+    }
     /**
      * This method retrieves queries the store with with passed record ids to retrieve their
      * associated records and object info. Note that the passed ids are not Salesforce record id
@@ -367,14 +397,10 @@ class AdsBridge {
         let shouldEmit = false;
         const adsRecordMap = {};
         const adsObjectMap = {};
-        for (let i = 0; i < updatedEntries.length; i++) {
-            const storeRecordId = updatedEntries[i].id;
-            // Exclude all the store record ids not matching with the record id pattern.
-            // Note: FieldValueRepresentation have the same prefix than RecordRepresentation so we
-            // need to filter them out.
-            if (!isStoreKeyRecordId(storeRecordId)) {
-                continue;
-            }
+        // Context for change: W-21715343
+        const filteredUpdatedEntries = this.filterAndSynthesizeBaseIds(updatedEntries);
+        for (let i = 0; i < filteredUpdatedEntries.length; i++) {
+            const storeRecordId = filteredUpdatedEntries[i].id;
             const record = this.recordRepresentationIngestOverride !== undefined
                 ? getShallowRecordDenormalized(luvio, storeRecordId)
                 : getShallowRecord(luvio, storeRecordId);
@@ -435,4 +461,4 @@ function withAdsBridge(callback) {
 }
 
 export { instrument, withAdsBridge };
-// version: 1.432.0-a57c62b660
+// version: 1.434.0-d8deb0d4ea

package/dist/types/ads-bridge.d.ts

@@ -78,6 +78,7 @@ export default class AdsBridge {
      * mutations triggered by ADS to be emit back to ADS.
      */
     private lockLdsRecordEmit;
+    private filterAndSynthesizeBaseIds;
     /**
      * This method retrieves queries the store with with passed record ids to retrieve their
      * associated records and object info. Note that the passed ids are not Salesforce record id

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-ads-bridge",
-    "version": "1.432.0",
+    "version": "1.434.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "Bridge to sync data between LDS and ADS",
     "main": "dist/adsBridge.js",
@@ -30,9 +30,9 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-ads-bridge"
     },
     "devDependencies": {
-        "@salesforce/lds-adapters-uiapi": "^1.432.0",
-        "@salesforce/lds-runtime-mobile": "^1.432.0",
-        "@salesforce/lds-uiapi-record-utils-mobile": "^1.432.0"
+        "@salesforce/lds-adapters-uiapi": "^1.434.0",
+        "@salesforce/lds-runtime-mobile": "^1.434.0",
+        "@salesforce/lds-uiapi-record-utils-mobile": "^1.434.0"
     },
     "volta": {
         "extends": "../../package.json"
@@ -41,9 +41,9 @@
         {
             "path": "./dist/adsBridge.js",
             "maxSize": {
-                "none": "17 kB",
-                "min": "5.51 kB",
-                "compressed": "4 kB"
+                "none": "18.4 kB",
+                "min": "6 kB",
+                "compressed": "4.3 kB"
             }
         }
     ]

package/src/__tests__/ads-bridge.spec.ts

@@ -1,5 +1,10 @@
 import { Luvio, InMemoryStore, Environment } from '@luvio/engine';
-import { keyBuilderRecord, ingestRecord, type Registration } from '@salesforce/lds-adapters-uiapi';
+import {
+    keyBuilderRecord,
+    ingestRecord,
+    type Registration,
+    ingestRecordSuccess,
+} from '@salesforce/lds-adapters-uiapi';
 import { expect } from '@jest/globals';
 
 import AdsBridge from '../ads-bridge';
@@ -417,6 +422,158 @@ describe('AdsBridge', () => {
             });
         });
 
+        // Context for change: W-21715343
+        it('correctly emits the updated Case record to ADS when refreshSnapshot is called, and the Case record was updated via spanning record updates on the Task record', async () => {
+            const initialLdsState = JSON.parse(JSON.stringify(require('./initial_record.json')));
+            const addRecordsGet = JSON.parse(JSON.stringify(require('./task_record_gvp_get.json')));
+            const addRecordsSave = JSON.parse(
+                JSON.stringify(require('./task_record_gvp_save.json'))
+            );
+            const addRecordsGet2 = JSON.parse(
+                JSON.stringify(require('./task_record_gvp_get2.json'))
+            );
+
+            const { bridge, luvio } = createBridge();
+            const caseId: string = initialLdsState.id;
+
+            const selector = {
+                recordId: keyBuilderRecord(luvio, { recordId: caseId }),
+                node: { kind: 'Fragment' as const, private: [] as string[] },
+                variables: {},
+            };
+
+            // Creating a refreshable snapshot of the Case record as we don't have the wire adapter bindings available to us in jest environment to refresh the snapshot manually.
+            const snapshot = luvio.storeLookup(selector, {
+                config: { recordId: caseId },
+                resolve: async () => {
+                    const response = await luvio.dispatchResourceRequest({
+                        baseUri: '',
+                        basePath: `/ui-api/records/${caseId}`,
+                        method: 'get',
+                        body: null,
+                        queryParams: {},
+                        urlParams: {},
+                        headers: {},
+                        priority: 'normal',
+                    });
+                    const config = {
+                        optionalFields: ['Case.Id'],
+                        recordId: caseId,
+                    };
+                    const trackedFields = ['Case.Status'];
+                    ingestRecordSuccess(luvio, config, caseId, trackedFields, response as any, 0);
+                    await luvio.storeBroadcast();
+                    return luvio.storeLookup(selector);
+                },
+            });
+
+            // 1. Prime LDS with the Case fixture (via addRecord → storeIngest + storeBroadcast).
+            addRecord(luvio, initialLdsState);
+
+            const expectedStatus = queryRecord(luvio, { recordId: caseId }).data.fields.Status;
+            expect(expectedStatus).toEqual({ value: 'New', displayValue: 'New' });
+
+            luvio.dispatchResourceRequest = jest.fn();
+
+            const fn = jest.fn();
+            bridge.receiveFromLdsCallback = fn;
+
+            // 2. Ingest the Task (+ spanning Case__r) via addRecords().
+            bridge.addRecords(addRecordsGet); // A RecordGvp.getRecord call is made to get the initial Task record when switching from the Case record to the Task record in console mode.
+            bridge.addRecords(addRecordsSave); // Clicking the complete button on the Task record which does a RecordGvp.saveRecord call.
+            bridge.addRecords(addRecordsGet2); // A RecordGvp.getRecord call is made to get the updated Task record.
+
+            expect(luvio.dispatchResourceRequest).toHaveBeenCalledTimes(0);
+
+            // 3. Synthesize the closed Case record server response which is expected to be received when the refreshSnapshot is called.
+            const closedCaseResponse = JSON.parse(JSON.stringify(require('./initial_record.json')));
+            closedCaseResponse.fields.Status = { value: 'Closed', displayValue: 'Closed' };
+            closedCaseResponse.weakEtag = addRecordsGet2[0].weakEtag;
+            closedCaseResponse.systemModstamp = addRecordsGet2[0].systemModstamp;
+            closedCaseResponse.lastModifiedDate = addRecordsGet2[0].lastModifiedDate;
+
+            luvio.dispatchResourceRequest = jest
+                .fn()
+                .mockResolvedValueOnce({ body: closedCaseResponse })
+                .mockImplementation(() => new Promise(() => {}));
+
+            // 4. Refresh the snapshot to get the updated Case record. This was previously not working because the interactions on the ADS-Bridge had updated the Case record with the latest weakEtag, but NOT the updated Status field value.
+            const refreshedSnapshot = await luvio.refreshSnapshot(snapshot);
+            expect((refreshedSnapshot.data as any).fields.Status).toEqual(
+                expect.objectContaining({ value: 'Closed' })
+            );
+
+            // 5. With the ADS-Bridge changes, the Case record is now emitted when the refreshSnapshot is called.
+            expect(fn.mock.calls[0]).toMatchInlineSnapshot(`
+                Array [
+                  Object {
+                    "500xx000000boDJAAY": Object {
+                      "Case": Object {
+                        "isPrimary": true,
+                        "record": Object {
+                          "apiName": "Case",
+                          "childRelationships": Object {},
+                          "eTag": "",
+                          "fields": Object {
+                            "CaseNumber": Object {
+                              "displayValue": null,
+                              "value": "00001026",
+                            },
+                            "Id": Object {
+                              "displayValue": null,
+                              "value": "500xx000000boDJAAY",
+                            },
+                            "IsEscalated": Object {
+                              "displayValue": null,
+                              "value": false,
+                            },
+                            "MasterRecordId": Object {
+                              "displayValue": null,
+                              "value": null,
+                            },
+                            "Priority": Object {
+                              "displayValue": "Medium",
+                              "value": "Medium",
+                            },
+                            "RecordTypeId": Object {
+                              "displayValue": null,
+                              "value": "012000000000000AAA",
+                            },
+                            "Status": Object {
+                              "displayValue": "Closed",
+                              "value": "Closed",
+                            },
+                            "Subject": Object {
+                              "displayValue": null,
+                              "value": "Fixture subject",
+                            },
+                            "SystemModstamp": Object {
+                              "displayValue": null,
+                              "value": "2026-04-11T00:46:56.000Z",
+                            },
+                          },
+                          "id": "500xx000000boDJAAY",
+                          "lastModifiedById": "005xx000001X8gHAAS",
+                          "lastModifiedDate": "2026-04-13T20:54:41.000Z",
+                          "recordTypeId": "012000000000000AAA",
+                          "recordTypeInfo": null,
+                          "systemModstamp": "2026-04-13T20:54:41.000Z",
+                          "weakEtag": 1776113681000,
+                        },
+                      },
+                    },
+                  },
+                  Object {
+                    "Case": Object {
+                      "_entityLabel": "Case",
+                      "_keyPrefix": "500",
+                      "_nameField": "Name",
+                    },
+                  },
+                ]
+            `);
+        });
+
         describe('displayValue', () => {
             it('does not let null overwrite non-null displayValue', () => {
                 const { bridge, luvio } = createBridge();
@@ -1383,6 +1540,82 @@ describe('AdsBridge', () => {
         });
     });
 
+    describe('filterAndSynthesizeBaseIds', () => {
+        const BASE_KEY = 'UiApi::RecordRepresentation:001xx000000001AAA';
+        const FIELD_KEY = 'UiApi::RecordRepresentation:001xx000000001AAA__fields__Name';
+        const BASE_KEY_2 = 'UiApi::RecordRepresentation:001xx000000002AAA';
+        const FIELD_KEY_2A = 'UiApi::RecordRepresentation:001xx000000002AAA__fields__Name';
+        const FIELD_KEY_2B = 'UiApi::RecordRepresentation:001xx000000002AAA__fields__Id';
+        const NON_RECORD_KEY = 'SomeOther::Thing:abc123';
+
+        function callFilter(bridge: AdsBridge, entries: { id: string }[]): { id: string }[] {
+            return (bridge as any).filterAndSynthesizeBaseIds(entries);
+        }
+
+        it('returns an empty array when given an empty array', () => {
+            const { bridge } = createBridge();
+            expect(callFilter(bridge, [])).toEqual([]);
+        });
+
+        it('filters out non-record entries', () => {
+            const { bridge } = createBridge();
+            const result = callFilter(bridge, [{ id: NON_RECORD_KEY }]);
+            expect(result).toEqual([]);
+        });
+
+        it('returns base record entries unchanged', () => {
+            const { bridge } = createBridge();
+            const result = callFilter(bridge, [{ id: BASE_KEY }]);
+            expect(result).toEqual([{ id: BASE_KEY }]);
+        });
+
+        it('synthesizes a base record entry for a field entry with no direct base entry', () => {
+            const { bridge } = createBridge();
+            const result = callFilter(bridge, [{ id: FIELD_KEY }]);
+            expect(result).toEqual([{ id: BASE_KEY }]);
+        });
+
+        it('does not synthesize a duplicate base entry when a direct base entry is already present', () => {
+            const { bridge } = createBridge();
+            const result = callFilter(bridge, [{ id: BASE_KEY }, { id: FIELD_KEY }]);
+            expect(result).toHaveLength(1);
+            expect(result).toEqual([{ id: BASE_KEY }]);
+        });
+
+        it('synthesizes exactly one base entry for multiple field entries sharing the same base', () => {
+            const { bridge } = createBridge();
+            const result = callFilter(bridge, [{ id: FIELD_KEY_2A }, { id: FIELD_KEY_2B }]);
+            expect(result).toHaveLength(1);
+            expect(result).toEqual([{ id: BASE_KEY_2 }]);
+        });
+
+        it('returns base entries and synthesizes entries for fields whose base is not directly present', () => {
+            const { bridge } = createBridge();
+            const entries = [
+                { id: BASE_KEY },
+                { id: FIELD_KEY },
+                { id: FIELD_KEY_2A },
+                { id: FIELD_KEY_2B },
+            ];
+            const result = callFilter(bridge, entries);
+            expect(result).toHaveLength(2);
+            expect(result).toContainEqual({ id: BASE_KEY });
+            expect(result).toContainEqual({ id: BASE_KEY_2 });
+        });
+
+        it('filters out non-record entries while still processing valid entries', () => {
+            const { bridge } = createBridge();
+            const result = callFilter(bridge, [
+                { id: NON_RECORD_KEY },
+                { id: BASE_KEY },
+                { id: FIELD_KEY_2A },
+            ]);
+            expect(result).toHaveLength(2);
+            expect(result).toContainEqual({ id: BASE_KEY });
+            expect(result).toContainEqual({ id: BASE_KEY_2 });
+        });
+    });
+
     describe('isDMOEntity', () => {
         it('should return true for DMO record', () => {
             const record = createRecord({

package/src/__tests__/initial_record.json

@@ -0,0 +1,50 @@
+{
+    "apiName": "Case",
+    "childRelationships": {},
+    "eTag": "",
+    "fields": {
+        "Id": {
+            "displayValue": null,
+            "value": "500xx000000boDJAAY"
+        },
+        "RecordTypeId": {
+            "displayValue": null,
+            "value": "012000000000000AAA"
+        },
+        "IsEscalated": {
+            "displayValue": null,
+            "value": false
+        },
+        "MasterRecordId": {
+            "displayValue": null,
+            "value": null
+        },
+        "SystemModstamp": {
+            "displayValue": null,
+            "value": "2026-04-11T00:46:56.000Z"
+        },
+        "CaseNumber": {
+            "displayValue": null,
+            "value": "00001026"
+        },
+        "Priority": {
+            "displayValue": "Medium",
+            "value": "Medium"
+        },
+        "Status": {
+            "displayValue": "New",
+            "value": "New"
+        },
+        "Subject": {
+            "displayValue": null,
+            "value": "Fixture subject"
+        }
+    },
+    "id": "500xx000000boDJAAY",
+    "lastModifiedById": "005xx000001X8gHAAS",
+    "lastModifiedDate": "2026-04-13T20:50:18.000Z",
+    "recordTypeId": "012000000000000AAA",
+    "recordTypeInfo": null,
+    "systemModstamp": "2026-04-13T20:50:18.000Z",
+    "weakEtag": 1776113418000
+}