@salesforce/lds-worker-api 1.136.6 → 1.136.8

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

@@ -20,7 +20,7 @@ var SnapshotState$3;
     SnapshotState["Stale"] = "Stale";
 })(SnapshotState$3 || (SnapshotState$3 = {}));
 
-const { create: create$a, entries: entries$4, freeze: freeze$5, keys: keys$a, values: values$3 } = Object;
+const { create: create$a, entries: entries$4, freeze: freeze$5, keys: keys$b, values: values$3 } = Object;
 const { hasOwnProperty: hasOwnProperty$3 } = Object.prototype;
 const { isArray: isArray$9 } = Array;
 const { push: push$4, indexOf, slice: slice$2 } = Array.prototype;
@@ -37,7 +37,7 @@ function deepFreeze(value) {
         }
     }
     else {
-        const keys$1 = keys$a(value);
+        const keys$1 = keys$b(value);
         for (let i = 0, len = keys$1.length; i < len; i += 1) {
             deepFreeze(value[keys$1[i]]);
         }
@@ -298,7 +298,7 @@ function stableJSONStringify$3(node) {
     if (node === null) {
         return 'null';
     }
-    const keys$1 = keys$a(node).sort();
+    const keys$1 = keys$b(node).sort();
     out = '';
     for (i = 0; i < keys$1.length; i++) {
         const key = keys$1[i];
@@ -569,13 +569,13 @@ class StringKeyInMemoryStore {
         return this.records[this.getCanonicalRecordId(key)];
     }
     getNumEntries() {
-        return keys$a(this.records).length;
+        return keys$b(this.records).length;
     }
     readMetadata(key) {
         return this.metadata[this.getCanonicalRecordId(key)];
     }
     readMetadataWhere(query) {
-        const keys$1 = keys$a(this.metadata);
+        const keys$1 = keys$b(this.metadata);
         const results = [];
         const hasNamespaceQuery = hasOwnProperty$3.call(query, 'namespace');
         const hasRepresentationNameQuery = hasOwnProperty$3.call(query, 'representationName');
@@ -671,8 +671,8 @@ class StringKeyInMemoryStore {
         // Note: we should always get the subscription references from this at the beginning
         // of the function, in case the reference changes (because of an unsubscribe)
         const { snapshotSubscriptions, watchSubscriptions, visitedIds, refreshedIds, insertedIds } = this;
-        const allVisitedIds = keys$a(visitedIds);
-        const allRefreshedIds = keys$a(refreshedIds);
+        const allVisitedIds = keys$b(visitedIds);
+        const allRefreshedIds = keys$b(refreshedIds);
         // Early exit if nothing has changed
         if (allVisitedIds.length === 0 && allRefreshedIds.length === 0) {
             return Promise.resolve();
@@ -1119,7 +1119,7 @@ function isPendingSnapshotWithNoOverlappingIds(snapshot, visitedIds, refreshedId
         hasOverlappingIds(snapshot, visitedIds) === false);
 }
 function getMatchingIds(partialKey, visitedIds) {
-    const keys$1 = keys$a(partialKey);
+    const keys$1 = keys$b(partialKey);
     return visitedIds.filter((visitedId) => {
         return keys$1.every((key) => {
             return partialKey[key] === visitedId[key];
@@ -1746,8 +1746,8 @@ class InMemoryStore {
         } while (redirectKey !== undefined);
     }
     isUsingStringKeys() {
-        return (keys$a(this.fallbackStringKeyInMemoryStore.visitedIds).length !== 0 ||
-            keys$a(this.fallbackStringKeyInMemoryStore.refreshedIds).length !== 0);
+        return (keys$b(this.fallbackStringKeyInMemoryStore.visitedIds).length !== 0 ||
+            keys$b(this.fallbackStringKeyInMemoryStore.refreshedIds).length !== 0);
     }
     delegateToFallbackStringKeyStore(snapshot) {
         return !isErrorSnapshot$3(snapshot) && typeof snapshot.recordId === 'string';
@@ -1789,7 +1789,7 @@ class InMemoryStore {
     buildKeySchema(keyMetadata) {
         // pull NamespacedType type out of NormalizedKeyMetadata
         const { namespace: _ns, representationName: _rn, ...keyParamValues } = keyMetadata;
-        const keySchema = keys$a(keyParamValues).sort();
+        const keySchema = keys$b(keyParamValues).sort();
         return ['namespace', 'representationName', ...keySchema];
     }
 }
@@ -2077,7 +2077,7 @@ class GraphNode {
         return value;
     }
     keys() {
-        return keys$a(this.data);
+        return keys$b(this.data);
     }
     isScalar(propertyName) {
         // TODO W-6900046 - merge.ts casts these to any and manually sets `data`
@@ -2456,7 +2456,7 @@ class Reader {
         }
     }
     selectAllObject(record, data, visitedKeys) {
-        const recordKeys = keys$a(record);
+        const recordKeys = keys$b(record);
         const { length } = recordKeys;
         for (let i = 0; i < length; i += 1) {
             const key = recordKeys[i];
@@ -2637,7 +2637,7 @@ class Reader {
         }
         const { baseSnapshotValue } = this.currentPath;
         if (isDefined$1(baseSnapshotValue)) {
-            this.snapshotChanged = keys$1.length !== keys$a(baseSnapshotValue).length;
+            this.snapshotChanged = keys$1.length !== keys$b(baseSnapshotValue).length;
         }
     }
     checkIfChanged(value) {
@@ -2675,7 +2675,7 @@ class Reader {
             return this.markMissing();
         }
         const sink = (data[propertyName] = {});
-        const keys$1 = keys$a(obj);
+        const keys$1 = keys$b(obj);
         this.checkIfObjectKeysLengthChanged(keys$1);
         for (let i = 0, len = keys$1.length; i < len; i += 1) {
             const key = keys$1[i];
@@ -2686,7 +2686,7 @@ class Reader {
     }
     readLinkMap(propertyName, selection, record, data) {
         const map = record[propertyName];
-        const keys$1 = keys$a(map);
+        const keys$1 = keys$b(map);
         const sink = {};
         this.checkIfObjectKeysLengthChanged(keys$1);
         for (let i = 0, len = keys$1.length; i < len; i += 1) {
@@ -2814,7 +2814,7 @@ class Reader {
             return;
         }
         const sink = (data[propertyName] = {});
-        const keys$1 = keys$a(obj);
+        const keys$1 = keys$b(obj);
         this.checkIfObjectKeysLengthChanged(keys$1);
         for (let i = 0, len = keys$1.length; i < len; i += 1) {
             const key = keys$1[i];
@@ -3497,13 +3497,13 @@ class Luvio {
         // undefined values on the injected networkAdapter.  So we do it here, on
         // the API that those adapters call to dispatch their ResourceRequests.
         const { queryParams, urlParams } = mergedResourceRequest;
-        for (const paramKey of keys$a(queryParams)) {
+        for (const paramKey of keys$b(queryParams)) {
             const value = queryParams[paramKey];
             if (value === undefined) {
                 delete queryParams[paramKey];
             }
         }
-        for (const paramKey of keys$a(urlParams)) {
+        for (const paramKey of keys$b(urlParams)) {
             const value = urlParams[paramKey];
             if (value === undefined) {
                 delete urlParams[paramKey];
@@ -3797,7 +3797,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.136.6-0f5ec3ee7
+// version: 1.136.8-1a1062e42
 
 // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
 function instrumentAdapter$1(createFunction, _metadata) {
@@ -15221,7 +15221,7 @@ function parseAndVisit(source) {
     updateReferenceMapWithKnownKey(ast, luvioDocumentNode);
     return luvioDocumentNode;
 }
-// version: 1.136.6-0f5ec3ee7
+// version: 1.136.8-1a1062e42
 
 function unwrap(data) {
     // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16134,7 +16134,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     const { apiFamily, name } = metadata;
     return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
-// version: 1.136.6-0f5ec3ee7
+// version: 1.136.8-1a1062e42
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -16221,7 +16221,7 @@ var FragmentReadResultState;
 
 const { keys: ObjectKeys$3, create: ObjectCreate$3 } = Object;
 
-const { assign: assign$7, create: create$8, freeze: freeze$4, keys: keys$9 } = Object;
+const { assign: assign$7, create: create$8, freeze: freeze$4, keys: keys$a } = Object;
 
 ObjectCreate$3(null);
 
@@ -17059,7 +17059,7 @@ function getTypeCacheKeys$Q(luvio, input, fullPathFactory) {
     return rootKeySet;
 }
 
-const { assign: assign$6, create: create$7, freeze: freeze$3, keys: keys$8 } = Object;
+const { assign: assign$6, create: create$7, freeze: freeze$3, keys: keys$9 } = Object;
 const { hasOwnProperty: hasOwnProperty$1 } = Object.prototype;
 const { split, endsWith } = String.prototype;
 const { isArray: isArray$7 } = Array;
@@ -17077,7 +17077,7 @@ const getTypeCacheKeys$P = (luvio, input, _fullPathFactory) => {
         mergeable: true,
     });
     const input_childRelationships = input.childRelationships;
-    const input_childRelationships_keys = keys$8(input_childRelationships);
+    const input_childRelationships_keys = keys$9(input_childRelationships);
     const input_childRelationships_length = input_childRelationships_keys.length;
     for (let i = 0; i < input_childRelationships_length; i++) {
         const key = input_childRelationships_keys[i];
@@ -17085,7 +17085,7 @@ const getTypeCacheKeys$P = (luvio, input, _fullPathFactory) => {
         rootKeySet.merge(cacheKeys);
     }
     const input_fields = input.fields;
-    const input_fields_keys = keys$8(input_fields);
+    const input_fields_keys = keys$9(input_fields);
     const input_fields_length = input_fields_keys.length;
     for (let i = 0; i < input_fields_length; i++) {
         const key = input_fields_keys[i];
@@ -17552,7 +17552,7 @@ function dedupe(value) {
     for (let i = 0, len = value.length; i < len; i += 1) {
         result[value[i]] = true;
     }
-    return keys$8(result);
+    return keys$9(result);
 }
 /**
  * @param source The array of string to filter
@@ -19000,7 +19000,7 @@ function convertRecordFieldsArrayToTrie(fields, optionalFields = []) {
 function createPathSelection(propertyName, fieldDefinition) {
     const fieldsSelection = [];
     const { children } = fieldDefinition;
-    const childrenKeys = keys$8(children);
+    const childrenKeys = keys$9(children);
     for (let i = 0, len = childrenKeys.length; i < len; i += 1) {
         const childKey = childrenKeys[i];
         const childFieldDefinition = children[childKey];
@@ -19045,7 +19045,7 @@ function createPathSelection(propertyName, fieldDefinition) {
  */
 function createPathSelectionFromValue(fields) {
     const fieldsSelection = [];
-    const fieldNames = keys$8(fields);
+    const fieldNames = keys$9(fields);
     for (let i = 0, len = fieldNames.length; i < len; i++) {
         const fieldName = fieldNames[i];
         const { value: fieldValue } = fields[fieldName];
@@ -19084,7 +19084,7 @@ function createPathSelectionFromValue(fields) {
 }
 function extractRecordFieldsRecursively(record) {
     const fields = [];
-    const fieldNames = keys$8(record.fields);
+    const fieldNames = keys$9(record.fields);
     for (let i = 0, len = fieldNames.length; i < len; i++) {
         const fieldName = fieldNames[i];
         const { value: fieldValue } = record.fields[fieldName];
@@ -19272,7 +19272,7 @@ function extractTrackedFieldsToTrie(recordId, node, root, config, visitedRecordI
                     continue;
                 }
                 extractTrackedFieldsToTrie(spanningLink.data.__ref, spanning, next, config, spanningVisitedRecordIds, depth + 1);
-                if (keys$8(next.children).length > 0) {
+                if (keys$9(next.children).length > 0) {
                     current.children[key] = next;
                 }
                 else {
@@ -19324,13 +19324,13 @@ function isExternalLookupFieldKey(spanningNode) {
     return endsWith.call(spanningNode.scalar('apiName'), CUSTOM_EXTERNAL_OBJECT_FIELD_SUFFIX);
 }
 function convertTrieToFields(root) {
-    if (keys$8(root.children).length === 0) {
+    if (keys$9(root.children).length === 0) {
         return [];
     }
     return convertTrieToFieldsRecursively(root);
 }
 function convertTrieToFieldsRecursively(root) {
-    const childKeys = keys$8(root.children);
+    const childKeys = keys$9(root.children);
     if (childKeys.length === 0) {
         if (root.name === '') {
             return [];
@@ -19367,7 +19367,7 @@ const getObjectNameFromField = (field) => {
 function mergeFieldsTries(rootA, rootB) {
     const rootAchildren = rootA.children;
     const rootBchildren = rootB.children;
-    const childBKeys = keys$8(rootBchildren);
+    const childBKeys = keys$9(rootBchildren);
     for (let i = 0, len = childBKeys.length; i < len; i++) {
         const childBKey = childBKeys[i];
         if (rootAchildren[childBKey] === undefined) {
@@ -19520,8 +19520,8 @@ function isSuperRecordFieldTrie(a, b) {
     }
     const childrenA = a.children;
     const childrenB = b.children;
-    const childKeysA = keys$8(childrenA);
-    const childKeysB = keys$8(childrenB);
+    const childKeysA = keys$9(childrenA);
+    const childKeysB = keys$9(childrenB);
     const childKeysBLength = childKeysB.length;
     if (childKeysBLength > childKeysA.length) {
         return false;
@@ -19545,7 +19545,7 @@ function mergePendingFields(newRecord, oldRecord) {
     // RecordRepresentationNormalized['fields'] to include `pending:true` property
     const mergedFields = { ...newRecord.fields };
     const merged = { ...newRecord, fields: mergedFields };
-    const existingFields = keys$8(oldRecord.fields);
+    const existingFields = keys$9(oldRecord.fields);
     for (let i = 0, len = existingFields.length; i < len; i += 1) {
         const spanningFieldName = existingFields[i];
         if (newRecord.fields[spanningFieldName] === undefined) {
@@ -19678,7 +19678,7 @@ function merge$3(existing, incoming, luvio, _path, recordConflictMap) {
         if (isGraphNode(node)) {
             const dependencies = node.retrieve();
             if (dependencies !== null) {
-                const depKeys = keys$8(dependencies);
+                const depKeys = keys$9(dependencies);
                 for (let i = 0, len = depKeys.length; i < len; i++) {
                     luvio.storeEvict(depKeys[i]);
                 }
@@ -19825,7 +19825,7 @@ function addFieldsToStoreLink(fieldsTrie, optionalFieldsTrie, storeLink) {
     }
     for (let i = 0; i < fieldSubtries.length; i++) {
         const subtrie = fieldSubtries[i];
-        const fieldNames = keys$8(subtrie.children);
+        const fieldNames = keys$9(subtrie.children);
         for (let i = 0; i < fieldNames.length; i++) {
             const fieldName = fieldNames[i];
             const childTrie = subtrie.children[fieldName];
@@ -19937,9 +19937,9 @@ function fulfill(existing, incoming) {
             return false;
         }
     }
-    const headersKeys = keys$8(headers);
+    const headersKeys = keys$9(headers);
     const headersKeyLength = headersKeys.length;
-    if (headersKeyLength !== keys$8(existingHeaders).length) {
+    if (headersKeyLength !== keys$9(existingHeaders).length) {
         return false;
     }
     for (let i = 0, len = headersKeyLength; i < len; i++) {
@@ -20708,7 +20708,7 @@ function buildNetworkSnapshot$V(luvio, config, serverRequestCount = 0, options)
 
 // iterate through the map to build configs for network calls
 function resolveConflict(luvio, map) {
-    const ids = keys$8(map.conflicts);
+    const ids = keys$9(map.conflicts);
     if (ids.length === 0) {
         instrumentation$2.recordConflictsResolved(map.serverRequestCount);
         return;
@@ -21888,18 +21888,18 @@ function listFields(luvio, { fields = [], optionalFields = [], sortBy, }, listIn
     return {
         getRecordSelectionFieldSets() {
             const optionalPlusDefaultFields = { ...optionalFields_ };
-            const fields = keys$8(defaultFields_);
+            const fields = keys$9(defaultFields_);
             for (let i = 0; i < fields.length; ++i) {
                 const field = fields[i];
                 if (!fields_[field] && !defaultServerFieldStatus.missingFields[field]) {
                     optionalPlusDefaultFields[field] = true;
                 }
             }
-            return [keys$8(fields_).sort(), keys$8(optionalPlusDefaultFields).sort()];
+            return [keys$9(fields_).sort(), keys$9(optionalPlusDefaultFields).sort()];
         },
         processRecords(records) {
             const { missingFields } = defaultServerFieldStatus;
-            const fields = keys$8(missingFields);
+            const fields = keys$9(missingFields);
             for (let i = 0; i < fields.length; ++i) {
                 const field = fields[i], splitField = field.split('.').slice(1);
                 for (let i = 0; i < records.length; ++i) {
@@ -24632,7 +24632,7 @@ function getMissingRecordLookupFields(record, objectInfo) {
     const lookupFields = {};
     const { apiName, fields: recordFields } = record;
     const { fields: objectInfoFields } = objectInfo;
-    const objectInfoFieldNames = keys$8(objectInfoFields);
+    const objectInfoFieldNames = keys$9(objectInfoFields);
     for (let i = 0, len = objectInfoFieldNames.length; i < len; i += 1) {
         const fieldName = objectInfoFieldNames[i];
         const field = objectInfoFields[fieldName];
@@ -24651,12 +24651,12 @@ function getMissingRecordLookupFields(record, objectInfo) {
         const nameField = `${apiName}.${relationshipName}.${getNameField(objectInfo, fieldName)}`;
         lookupFields[nameField] = true;
     }
-    return keys$8(lookupFields);
+    return keys$9(lookupFields);
 }
 function getRecordUiMissingRecordLookupFields(recordUi) {
     const { records, objectInfos } = recordUi;
     const recordLookupFields = {};
-    const recordIds = keys$8(records);
+    const recordIds = keys$9(records);
     for (let i = 0, len = recordIds.length; i < len; i += 1) {
         const recordId = recordIds[i];
         const recordData = records[recordId];
@@ -24694,19 +24694,19 @@ function buildCachedSelectorKey(key) {
 }
 function eachLayout(recordUi, cb) {
     const { layouts } = recordUi;
-    const layoutApiNames = keys$8(layouts);
+    const layoutApiNames = keys$9(layouts);
     for (let a = 0, len = layoutApiNames.length; a < len; a += 1) {
         const apiName = layoutApiNames[a];
         const apiNameData = layouts[apiName];
-        const recordTypeIds = keys$8(apiNameData);
+        const recordTypeIds = keys$9(apiNameData);
         for (let b = 0, recordTypeIdsLen = recordTypeIds.length; b < recordTypeIdsLen; b += 1) {
             const recordTypeId = recordTypeIds[b];
             const recordTypeData = apiNameData[recordTypeId];
-            const layoutTypes = keys$8(recordTypeData);
+            const layoutTypes = keys$9(recordTypeData);
             for (let c = 0, layoutTypesLen = layoutTypes.length; c < layoutTypesLen; c += 1) {
                 const layoutType = layoutTypes[c];
                 const layoutTypeData = recordTypeData[layoutType];
-                const modes = keys$8(layoutTypeData);
+                const modes = keys$9(layoutTypeData);
                 for (let d = 0, modesLen = modes.length; d < modesLen; d += 1) {
                     const mode = modes[d];
                     const layout = layoutTypeData[mode];
@@ -25085,11 +25085,11 @@ const recordLayoutFragmentSelector = [
 ];
 function getFieldsFromLayoutMap(layoutMap, objectInfo) {
     let fields = [];
-    const layoutTypes = keys$8(layoutMap);
+    const layoutTypes = keys$9(layoutMap);
     for (let i = 0, layoutTypesLen = layoutTypes.length; i < layoutTypesLen; i += 1) {
         const layoutType = layoutTypes[i];
         const modesMap = layoutMap[layoutType];
-        const modes = keys$8(modesMap);
+        const modes = keys$9(modesMap);
         for (let m = 0, modesLen = modes.length; m < modesLen; m += 1) {
             const mode = modes[m];
             const modeKeys = getQualifiedFieldApiNamesFromLayout(modesMap[mode], objectInfo);
@@ -29195,10 +29195,10 @@ function getTypeCacheKeys$x$1(luvio, input, fullPathFactory) {
 }
 
 const TTL$l = 300000;
-const VERSION$N$1 = "38ee38ead5262047cfa7604e8bf72d4b";
+const VERSION$N$1 = "1781f2d3d4e413cf0c681774d82d02cd";
 const RepresentationType$v = 'AppRepresentation';
 function keyBuilder$17(luvio, config) {
-    return keyPrefix$1 + '::' + RepresentationType$v + ':' + config.appId;
+    return keyPrefix$1 + '::' + RepresentationType$v + ':' + (config.appId === null ? '' : config.appId);
 }
 function keyBuilderFromType$j(luvio, object) {
     const keyParams = {
@@ -29346,11 +29346,6 @@ function equals$A(existing, incoming) {
     if (!(existing_selected === incoming_selected)) {
         return false;
     }
-    const existing_appId = existing.appId;
-    const incoming_appId = incoming.appId;
-    if (!(existing_appId === incoming_appId)) {
-        return false;
-    }
     const existing_developerName = existing.developerName;
     const incoming_developerName = incoming.developerName;
     if (!(existing_developerName === incoming_developerName)) {
@@ -29386,6 +29381,11 @@ function equals$A(existing, incoming) {
     if (!(existing_type === incoming_type)) {
         return false;
     }
+    const existing_appId = existing.appId;
+    const incoming_appId = incoming.appId;
+    if (!(existing_appId === incoming_appId)) {
+        return false;
+    }
     const existing_description = existing.description;
     const incoming_description = incoming.description;
     if (!(existing_description === incoming_description)) {
@@ -40017,7 +40017,7 @@ function optimisticUpdate(cachedLayoutUserState, layoutUserStateInput) {
     let clonedLayoutUserStateSections;
     const { sectionUserStates } = layoutUserStateInput;
     const { sectionUserStates: cachedSectionUserStates } = cachedLayoutUserState;
-    const sectionUserStateKeys = keys$8(sectionUserStates);
+    const sectionUserStateKeys = keys$9(sectionUserStates);
     for (let i = 0, len = sectionUserStateKeys.length; i < len; i += 1) {
         const sectionId = sectionUserStateKeys[i];
         if (cachedSectionUserStates[sectionId] === undefined) {
@@ -43901,7 +43901,7 @@ withDefaultLuvio((luvio) => {
         dropFunction: instrumentation$2.notifyRecordUpdateAvailableDropped,
     });
 });
-// version: 1.136.6-acf28210f
+// version: 1.136.8-449f5be71
 
 var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -43979,7 +43979,7 @@ function formattingOptions(pattern) {
 const { parse: parse$5, stringify: stringify$5 } = JSON;
 const { join: join$2, push: push$2, unshift } = Array.prototype;
 const { isArray: isArray$5 } = Array;
-const { entries: entries$3, keys: keys$6 } = Object;
+const { entries: entries$3, keys: keys$7 } = Object;
 
 const UI_API_BASE_URI = '/services/data/v59.0/ui-api';
 
@@ -44044,7 +44044,7 @@ function isSpanningRecord$1(fieldValue) {
 function mergeRecordFields$1(first, second) {
     const { fields: targetFields } = first;
     const { fields: sourceFields } = second;
-    const fieldNames = keys$6(sourceFields);
+    const fieldNames = keys$7(sourceFields);
     for (let i = 0, len = fieldNames.length; i < len; i += 1) {
         const fieldName = fieldNames[i];
         const sourceField = sourceFields[fieldName];
@@ -44448,7 +44448,7 @@ function isDeprecatedDurableStoreEntry(durableRecord) {
 }
 const DefaultDurableSegment = 'DEFAULT';
 
-const { keys: keys$5, create: create$5, assign: assign$4, freeze: freeze$1$1 } = Object;
+const { keys: keys$6, create: create$5, assign: assign$4, freeze: freeze$1$1 } = Object;
 
 //Durable store error instrumentation key
 const DURABLE_STORE_ERROR = 'durable-store-error';
@@ -44492,7 +44492,7 @@ function publishDurableStoreEntries(durableRecords, put, publishMetadata) {
     if (durableRecords === undefined) {
         return { revivedKeys, hadUnexpectedShape };
     }
-    const durableKeys = keys$5(durableRecords);
+    const durableKeys = keys$6(durableRecords);
     if (durableKeys.length === 0) {
         // no records to revive
         return { revivedKeys, hadUnexpectedShape };
@@ -44666,7 +44666,7 @@ class DurableTTLStore {
                     overrides,
                 };
             }
-            const keys$1 = keys$5(entries);
+            const keys$1 = keys$6(entries);
             for (let i = 0, len = keys$1.length; i < len; i++) {
                 const key = keys$1[i];
                 const entry = entries[key];
@@ -44694,7 +44694,7 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
     // TODO: W-8909393 Once metadata is stored in its own segment we need to
     // call setEntries for the visitedIds on default segment and call setEntries
     // on the metadata segment for the refreshedIds
-    const keys$1 = keys$5({ ...visitedIds, ...refreshedIds });
+    const keys$1 = keys$6({ ...visitedIds, ...refreshedIds });
     for (let i = 0, len = keys$1.length; i < len; i += 1) {
         const key = keys$1[i];
         const record = records[key];
@@ -44716,7 +44716,7 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
     }
     const durableStoreOperations = [];
     // publishes
-    const recordKeys = keys$5(durableRecords);
+    const recordKeys = keys$6(durableRecords);
     if (recordKeys.length > 0) {
         durableStoreOperations.push({
             type: 'setEntries',
@@ -44725,7 +44725,7 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
         });
     }
     // evicts
-    const evictedKeys = keys$5(evictedRecords);
+    const evictedKeys = keys$6(evictedRecords);
     if (evictedKeys.length > 0) {
         durableStoreOperations.push({
             type: 'evictEntries',
@@ -44879,7 +44879,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             try {
                 const entries = await durableStore.getEntries(adapterContextKeysFromDifferentInstance, AdapterContextSegment);
                 if (entries !== undefined) {
-                    const entryKeys = keys$5(entries);
+                    const entryKeys = keys$6(entries);
                     for (let i = 0, len = entryKeys.length; i < len; i++) {
                         const entryKey = entryKeys[i];
                         const entry = entries[entryKey];
@@ -45696,6 +45696,12 @@ function getRelationshipInfo(apiName, fieldName, infoMap) {
 function stringLiteral(value, safe = false, isCaseSensitive = false) {
     return { type: ValueType.StringLiteral, value, safe, isCaseSensitive };
 }
+function isStringLiteral(expression) {
+    return expression.type === ValueType.StringLiteral;
+}
+function isStringArray(expression) {
+    return expression.type === ValueType.StringArray;
+}
 function comparison(left, operator, right) {
     return { type: PredicateType$1.comparison, left, right, operator };
 }
@@ -46466,6 +46472,9 @@ function compoundOperatorToSql(operator) {
     }
 }
 
+const { isArray: isArray$4 } = Array;
+const { keys: keys$5 } = Object;
+
 function isListValueNode(node) {
     return node.kind === 'ListValue';
 }
@@ -46518,13 +46527,13 @@ function isScalarDataType(type) {
 const NotOperator = 'not';
 const { eq, ne, gt, gte, lt, lte, nin, like, includes, excludes } = ComparisonOperator;
 const inOp = ComparisonOperator.in;
-function fieldsToFilters(fieldValues, joinAlias, apiName, input, compoundOperator = CompoundOperator.and, joins) {
+function fieldsToFilters(fieldValues, joinAlias, apiName, input, compoundOperator = CompoundOperator.and, joins, draftFunctions) {
     const results = fieldValues
         .map((value) => {
         if (!isObjectValueNode$1(value)) {
             return [failure([message('Parent filter node should be an object.')])];
         }
-        return Object.entries(value.fields).map(([key, value]) => filter(key, value, joinAlias, apiName, input, joins));
+        return Object.entries(value.fields).map(([key, value]) => filter(key, value, joinAlias, apiName, input, joins, draftFunctions));
     })
         .reduce(flatten$1, []);
     const failures = results.filter(isFailure).reduce(flatMap$1(errors), []);
@@ -46546,22 +46555,22 @@ function fieldsToFilters(fieldValues, joinAlias, apiName, input, compoundOperato
     return success({ predicate: resolvedPredicate });
 }
 //{where: {Field: ... | and: ... | or: ... | not: ...}}
-function recordFilter(where, joinAlias, apiName, input, joins) {
+function recordFilter(where, joinAlias, apiName, input, joins, draftFunctions) {
     if (where === undefined) {
         return success(undefined);
     }
     // when 'recordFilter' starts, there is no 'NotPredicated'
-    return fieldsToFilters([where.value], joinAlias, apiName, input, CompoundOperator.and, joins).map((result) => result.predicate === undefined || isEmptyPredicate(result.predicate) ? undefined : result);
+    return fieldsToFilters([where.value], joinAlias, apiName, input, CompoundOperator.and, joins, draftFunctions).map((result) => result.predicate === undefined || isEmptyPredicate(result.predicate) ? undefined : result);
 }
-function filter(name, value, tableAlias, apiName, input, joins) {
+function filter(name, value, tableAlias, apiName, input, joins, draftFunctions) {
     if (isCompoundOperator(name)) {
         if (!isListValueNode(value)) {
             return failure([message(`Value for ${name} node must be a list.`)]);
         }
-        return compoundPredicate(name, value, tableAlias, apiName, input, joins);
+        return compoundPredicate(name, value, tableAlias, apiName, input, joins, draftFunctions);
     }
     if (name === NotOperator) {
-        const children = fieldsToFilters([value], tableAlias, apiName, input, CompoundOperator.and, joins);
+        const children = fieldsToFilters([value], tableAlias, apiName, input, CompoundOperator.and, joins, draftFunctions);
         // take the children of a not predicate
         // and wrap them all inside it
         return children.flatMap((container) => {
@@ -46579,10 +46588,10 @@ function filter(name, value, tableAlias, apiName, input, joins) {
     if (!isObjectValueNode$1(value)) {
         return failure([message('Filter node must be an object or list.')]);
     }
-    return fieldFilter(name, value, tableAlias, apiName, input, joins);
+    return fieldFilter(name, value, tableAlias, apiName, input, joins, draftFunctions);
 }
-function compoundPredicate(operator, list, joinAlias, apiName, input, joins) {
-    return fieldsToFilters(list.values, joinAlias, apiName, input, operator, joins);
+function compoundPredicate(operator, list, joinAlias, apiName, input, joins, draftFunctions) {
+    return fieldsToFilters(list.values, joinAlias, apiName, input, operator, joins, draftFunctions);
 }
 /**
  * spans a FieldNode with its ObjectValueNode is passed. All the predicates is added into the 'join' array.
@@ -46593,7 +46602,7 @@ function compoundPredicate(operator, list, joinAlias, apiName, input, joins) {
  * @param joins
  * @returns undefined predicate
  */
-function spanningFilter(fieldInfo, fieldNode, alias, input, joins) {
+function spanningFilter(fieldInfo, fieldNode, alias, input, joins, draftFunctions) {
     const { apiName: fieldName, referenceToInfos, relationshipName } = fieldInfo;
     const referenceInfo = referenceToInfos[0];
     const jsonAlias = `${alias}.${relationshipName}`;
@@ -46612,7 +46621,7 @@ function spanningFilter(fieldInfo, fieldNode, alias, input, joins) {
     joins.push(join);
     // moves constraint predicate to where
     const constraintPredicates = [];
-    const filterResult = fieldsToFilters([fieldNode], jsonAlias, apiName, input, CompoundOperator.and, joins);
+    const filterResult = fieldsToFilters([fieldNode], jsonAlias, apiName, input, CompoundOperator.and, joins, draftFunctions);
     if (filterResult.isSuccess === false) {
         return filterResult;
     }
@@ -46624,7 +46633,11 @@ function spanningFilter(fieldInfo, fieldNode, alias, input, joins) {
     });
     return success({ predicate: combinePredicates(constraintPredicates, CompoundOperator.and) });
 }
-function fieldFilter(fieldName, fieldNode, alias, apiName, input, joins) {
+function isIDValueField$1(fieldInfo) {
+    return (fieldInfo.apiName === 'Id' ||
+        (fieldInfo.referenceToInfos !== undefined && fieldInfo.referenceToInfos.length > 0));
+}
+function fieldFilter(fieldName, fieldNode, alias, apiName, input, joins, draftFunctions) {
     const fieldInfoResult = getFieldInfo(apiName, fieldName, input);
     if (fieldInfoResult.isSuccess === false) {
         return failure([fieldInfoResult.error]);
@@ -46634,8 +46647,9 @@ function fieldFilter(fieldName, fieldNode, alias, apiName, input, joins) {
         return failure([message(`Field ${fieldName} for type ${apiName} not found.`)]);
     }
     if (fieldInfo.dataType === 'Reference' && fieldInfo.relationshipName === fieldName) {
-        return spanningFilter(fieldInfo, fieldNode, alias, input, joins);
+        return spanningFilter(fieldInfo, fieldNode, alias, input, joins, draftFunctions);
     }
+    const idProcessingNeeded = isIDValueField$1(fieldInfo);
     const extract = {
         type: ValueType.Extract,
         jsonAlias: alias,
@@ -46726,7 +46740,29 @@ function fieldFilter(fieldName, fieldNode, alias, apiName, input, joins) {
                 children,
             };
         }
-        return comparison(extract, op.operator, op.value);
+        const rightOperand = op.value;
+        if (idProcessingNeeded) {
+            if (isStringLiteral(rightOperand)) {
+                if (rightOperand.value !== null) {
+                    if (draftFunctions.isDraftId(rightOperand.value)) {
+                        rightOperand.value = draftFunctions.getCanonicalId(rightOperand.value);
+                    }
+                }
+            }
+            else if (isStringArray(rightOperand)) {
+                if (rightOperand.value !== null) {
+                    rightOperand.value = rightOperand.value.map((originalId) => {
+                        if (originalId !== null) {
+                            if (draftFunctions.isDraftId(originalId)) {
+                                return draftFunctions.getCanonicalId(originalId);
+                            }
+                        }
+                        return originalId;
+                    });
+                }
+            }
+        }
+        return comparison(extract, op.operator, rightOperand);
     });
     const combined = combinePredicates(comparisons.concat(...dateFunction.value), CompoundOperator.and);
     const container = {
@@ -47828,7 +47864,7 @@ function recordQuery(selection, apiName, alias, predicates, input) {
     const orderByJoins = [];
     const orderByResult = parseOrderBy(orderByArg, alias, apiName, input.objectInfoMap, orderByJoins);
     const filterJoins = [];
-    const whereResult = recordFilter(whereArg, alias, apiName, input.objectInfoMap, filterJoins);
+    const whereResult = recordFilter(whereArg, alias, apiName, input.objectInfoMap, filterJoins, input.draftFunctions);
     const scopeJoins = [];
     const scopeResult = scopeFilter(scopeArg, alias, apiName, input, scopeJoins);
     let additionalPredicates = [];
@@ -47990,27 +48026,19 @@ function generateVariableGQLQuery(document, variables) {
             ? node.arguments
                 .map((args) => {
                 const { value, name } = args;
+                //The variable is on the top level, for example `where: ${filter}`
                 if (is(value, 'Variable')) {
-                    const variable = variables[value.name];
-                    if (variable) {
-                        const jsonString = JSON.stringify(variable);
-                        const buildRecordQueryString = (name, query, transform) => {
-                            return `${name}: ${transform(query)}`;
-                        };
-                        switch (name) {
-                            case 'scope':
-                            case 'orderBy':
-                                return buildRecordQueryString(name, jsonString, removeAllQuotations);
-                            default:
-                                return buildRecordQueryString(name, jsonString, removeQuotationsFromKeys);
-                        }
-                    }
-                    return '';
+                    return generateVariableNodeQuery(value, name, name, variables);
+                }
+                else if (isObjectValueNode$1(value)) {
+                    return generateVariableSubQuery(value, name, name, variables);
                 }
             })
                 .filter(Boolean)
             : undefined;
-        return gqlArguments ? `${node.name}(${gqlArguments.join(',')}) { Id }` : '';
+        return gqlArguments
+            ? `${node.name} ${gqlArguments.length > 0 ? '(' + gqlArguments.join(',') + ')' : ''} { Id }`
+            : '';
     })
         //remove empty strings
         .filter(Boolean)
@@ -48020,6 +48048,51 @@ function generateVariableGQLQuery(document, variables) {
         return [accu.slice(0, 1), query, accu.slice(1, length)].join('');
     }, '{ }'));
 }
+/**
+ * Given a  LuvioValueNode, generates a sql with its variable node replaced with actual value.
+ * @param valueNode G
+ * @param name
+ * @param type
+ * @param variables
+ * @returns
+ */
+function generateVariableSubQuery(valueNode, name, type, variables) {
+    switch (valueNode.kind) {
+        case Kind.OBJECT: {
+            // For example, `{ Id: { eq: $draftId } }` is a `ObjectValueNode`, which has field keys 'Id'
+            const resultQuery = keys$5(valueNode.fields)
+                .map((key) => generateVariableSubQuery(valueNode.fields[key], key, type, variables))
+                .filter((subquery) => subquery.length > 0)
+                .join(',');
+            if (resultQuery.length > 0) {
+                return `${name}: {${resultQuery}}`;
+            }
+            return resultQuery;
+        }
+        case Kind.VARIABLE:
+            return generateVariableNodeQuery(valueNode, name, type, variables);
+        default:
+            return '';
+    }
+}
+// Generate a sql for the variable node with its actual value.
+function generateVariableNodeQuery(value, name, type, variables) {
+    const variable = variables[value.name];
+    if (variable) {
+        const jsonString = JSON.stringify(variable);
+        const buildRecordQueryString = (name, query, transform) => {
+            return `${name}: ${transform(query)}`;
+        };
+        switch (type) {
+            case 'scope':
+            case 'orderBy':
+                return buildRecordQueryString(name, jsonString, removeAllQuotations);
+            default:
+                return buildRecordQueryString(name, jsonString, removeQuotationsFromKeys);
+        }
+    }
+    return '';
+}
 /**
  * Given an AST with variables
  * Swap out the LuvioArgumentNodes on the original AST with ones generated from its variables.
@@ -48038,14 +48111,43 @@ function swapVariableArguments(document, variables) {
             const { name } = node;
             const first = allArgumentRecords.find((n) => n.name === name);
             if (first) {
-                // if we had arguments that did not contain variables we still want those
-                first.arguments = flatten$1(first.arguments
-                    ? first.arguments.filter((x) => x.value.kind !== 'Variable')
-                    : [], node.arguments ? node.arguments : []);
+                const swappedArgments = swapArgumentWithVariableNodes(node.arguments, first.arguments);
+                first.arguments = swappedArgments ? swappedArgments : [];
             }
         });
     }
 }
+// Replaces the variable node  in original LuvioArgumentNode with the actual value in the swapped node with the same path.
+function swapArgumentWithVariableNodes(swapped, original) {
+    if (swapped === undefined || original === undefined) {
+        return original;
+    }
+    return original.map((x) => {
+        const targetNode = swapped.find((y) => y.name === x.name);
+        if (targetNode === undefined) {
+            return x;
+        }
+        if (x.value.kind === 'Variable') {
+            return targetNode;
+        }
+        swapValueNodeWithVariableNodes(x.value, targetNode.value);
+        return x;
+    });
+}
+function swapValueNodeWithVariableNodes(original, swapped) {
+    if (original.kind === Kind.OBJECT) {
+        for (const key of keys$5(original.fields)) {
+            if (isObjectValueNode$1(swapped) && swapped.fields[key]) {
+                if (is(original.fields[key], 'Variable')) {
+                    original.fields[key] = swapped.fields[key];
+                }
+                else {
+                    swapValueNodeWithVariableNodes(original.fields[key], swapped.fields[key]);
+                }
+            }
+        }
+    }
+}
 //find top level record queries
 function findRecordSelections$1(document) {
     return document.definitions
@@ -48080,7 +48182,7 @@ class StoreEvalPreconditioner {
      * Missing object info records triggers the objectInfoService (same instance shared with Drafts code), to
      * use the getObjectInfos adapter to efficiently fetch the necessary records.
      */
-    async createRootQuery(config, objectInfoService, userId) {
+    async createRootQuery(config, objectInfoService, userId, draftFunctions) {
         const { query: ast, variables } = config;
         swapVariableArguments(ast, variables);
         // Parse out top-level record queries types we know we will need, since spanning fields will
@@ -48127,6 +48229,7 @@ class StoreEvalPreconditioner {
             astTransformResult = transform(ast, {
                 userId,
                 objectInfoMap,
+                draftFunctions,
             });
             if (astTransformResult.isSuccess === false) {
                 for (const error of astTransformResult.error) {
@@ -48164,8 +48267,6 @@ class StoreEvalPreconditioner {
     }
 }
 
-const { isArray: isArray$4 } = Array;
-
 /**
  * Checks a GraphQL-shaped network response for errors, returning true if it does
  * and false otherwise
@@ -48211,7 +48312,7 @@ const wrapStartEndEvents = (storeEval) => {
         return snapshot;
     };
 };
-function sqliteStoreEvalFactory(userId, sqliteStore, objectInfoService) {
+function sqliteStoreEvalFactory(userId, sqliteStore, objectInfoService, draftFunctions) {
     // if the store does not support eval then use the noop version
     if (sqliteStore.isEvalSupported() === false) {
         return noopStoreEval;
@@ -48219,7 +48320,7 @@ function sqliteStoreEvalFactory(userId, sqliteStore, objectInfoService) {
     const preconditioner = new StoreEvalPreconditioner();
     return makeStoreEval(preconditioner, objectInfoService, userId, async () => {
         return undefined;
-    }, (query, _context, eventEmitter) => evaluateSqlite(query, eventEmitter, sqliteStore));
+    }, (query, _context, eventEmitter) => evaluateSqlite(query, eventEmitter, sqliteStore), draftFunctions);
 }
 async function noopStoreEval(_config, nonEvaluatedSnapshotOrPromise, _observers) {
     return nonEvaluatedSnapshotOrPromise;
@@ -48238,7 +48339,7 @@ function isErrorSnapshotThatShouldGetReturnedToCaller$1(snapshot) {
 function generateUniqueRecordId$1() {
     return `${GRAPHQL_ROOT_KEY$1}${Date.now() + Math.random().toFixed(5).split('.')[1]}`;
 }
-function makeStoreEval(preconditioner, objectInfoService, userId, contextProvider, queryEvaluator) {
+function makeStoreEval(preconditioner, objectInfoService, userId, contextProvider, queryEvaluator, draftFunctions) {
     const storeEval = async (config, nonEvaluatedSnapshotOrPromise, observers) => {
         const eventEmitter = createCustomAdapterEventEmitter(GRAPHQL_EVAL_NAMESPACE$1, observers);
         // the non-eval'ed input could either be a snapshot or promise of one so
@@ -48268,7 +48369,7 @@ function makeStoreEval(preconditioner, objectInfoService, userId, contextProvide
             context = await contextProvider();
             // Ensures ObjectInfo metadata is available for the request.  Sourcing records from L1/L2/Network
             // is delegated to the getObjectInfo adapter via objectInfoService
-            rootQuery = await preconditioner.createRootQuery(config, objectInfoService, userId);
+            rootQuery = await preconditioner.createRootQuery(config, objectInfoService, userId, draftFunctions);
         }
         catch (error) {
             eventEmitter({
@@ -56222,7 +56323,7 @@ function generateUniqueRecordId() {
     return `UiApi::GraphQLRepresentation:${Date.now() + Math.random().toFixed(5).split('.')[1]}`;
 }
 // Recursively replace draft ids with canonical ids
-const replaceDraftIdsInVariables = (variables, draftFunctions, unmappedDraftIDs) => {
+const replaceDraftIdsInVariables$1 = (variables, draftFunctions, unmappedDraftIDs) => {
     const replace = (object) => {
         if (typeof object === 'string') {
             if (!draftFunctions.isDraftId(object)) {
@@ -56279,7 +56380,7 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
                 unmappedDraftIDs,
             } = await injectSyntheticFields(copy, objectInfoService, draftFunctions, config.variables));
             if (config.variables) {
-                config.variables = replaceDraftIdsInVariables(config.variables, draftFunctions, unmappedDraftIDs);
+                config.variables = replaceDraftIdsInVariables$1(config.variables, draftFunctions, unmappedDraftIDs);
             }
         }
         catch (throwable) {
@@ -57865,7 +57966,7 @@ function makeNetworkAdapterChunkRecordFields(networkAdapter) {
     }, networkAdapter);
 }
 
-const { keys: keys$7, create: create$6, assign: assign$5, entries } = Object;
+const { keys: keys$8, create: create$6, assign: assign$5, entries } = Object;
 const { stringify: stringify$6, parse: parse$6 } = JSON;
 const { push, join, slice } = Array.prototype;
 
@@ -58425,7 +58526,7 @@ class LdsDataTable {
             },
             conflictColumns: this.conflictColumnNames,
             columns: this.columnNames,
-            rows: keys$7(entries).reduce((rows, key) => {
+            rows: keys$8(entries).reduce((rows, key) => {
                 const entry = entries[key];
                 const { data, metadata } = entry;
                 const row = [key, stringify$6(data), metadata ? stringify$6(metadata) : null];
@@ -58486,7 +58587,7 @@ class AbstractKeyValueDataTable {
             },
             conflictColumns: this.conflictColumnNames,
             columns: this.columnNames,
-            rows: keys$7(entries).reduce((rows, key) => {
+            rows: keys$8(entries).reduce((rows, key) => {
                 const entry = entries[key];
                 rows.push([key, stringify$6(entry.data)]);
                 return rows;
@@ -58571,7 +58672,7 @@ class LdsInternalDataTable {
             },
             conflictColumns: this.conflictColumnNames,
             columns: this.columnNames,
-            rows: keys$7(entries).reduce((rows, key) => {
+            rows: keys$8(entries).reduce((rows, key) => {
                 const entry = entries[key];
                 const { data, metadata } = entry;
                 const row = [key, stringify$6(data)];
@@ -59435,11 +59536,6 @@ function getRuntime() {
         getIngestMetadataForInternalAdapters =
             internalAdapterDurableEnvironment.getIngestStagingStoreRecords;
         lazyObjectInfoService = new ObjectInfoService(getObjectInfo, getObjectInfos, internalAdapterDurableStore);
-        // set storeEval function for lds-adapters-graghql to use
-        withRegistration('@salesforce/lds-adapters-graphql', (registration) => {
-            const { configuration: { setStoreEval }, } = registration;
-            setStoreEval(sqliteStoreEvalFactory(userId, lazyBaseDurableStore, lazyObjectInfoService));
-        });
         // creates a durable store that denormalizes scalar fields for records
         let getIngestRecords;
         let getIngestMetadata;
@@ -59478,6 +59574,20 @@ function getRuntime() {
         setupMobileInstrumentation();
         // If the inspection nimbus plugin is configured, inspection is enabled otherwise this is a no-op
         setupInspection(lazyLuvio);
+        // set storeEval function for lds-adapters-graghql to use
+        withRegistration('@salesforce/lds-adapters-graphql', (registration) => {
+            const { configuration: { setStoreEval, setDraftFunctions }, } = registration;
+            const getCanonicalId = (id) => {
+                var _a;
+                return ((_a = extractRecordIdFromStoreKey(lazyLuvio.storeGetCanonicalKey(RECORD_ID_PREFIX + id))) !== null && _a !== void 0 ? _a : id);
+            };
+            const draftFuncs = {
+                isDraftId: isGenerated,
+                getCanonicalId,
+            };
+            setStoreEval(sqliteStoreEvalFactory(userId, lazyBaseDurableStore, lazyObjectInfoService, draftFuncs));
+            setDraftFunctions(draftFuncs);
+        });
         // on core the graphql configuration is split so we need to set configureUIAPIGraphQL both in the
         // graphql registration and the uiapi for off core
         const configureUIAPIGraphQL = (registration) => {
@@ -59527,7 +59637,7 @@ register({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$1,
 });
-// version: 1.136.6-0f5ec3ee7
+// version: 1.136.8-1a1062e42
 
 const { create: create$2, keys: keys$2 } = Object;
 const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -73961,7 +74071,7 @@ register({
     configuration: { ...configurationForGraphQLAdapters },
     instrument,
 });
-// version: 1.136.6-acf28210f
+// version: 1.136.8-449f5be71
 
 // On core the unstable adapters are re-exported with different names,
 
@@ -75333,10 +75443,14 @@ function validate(ast, variables) {
 }
 
 let storeEval = undefined;
+let draftFunctions = undefined;
 const configuration = {
     setStoreEval: function (storeEvalArg) {
         storeEval = storeEvalArg;
     },
+    setDraftFunctions: function (draftFuncs) {
+        draftFunctions = draftFuncs;
+    },
 };
 
 const assignedToMe = {
@@ -75422,6 +75536,78 @@ function shouldInjectFields(ast) {
 function injectFieldsGQL(ast) {
     return injectScopeFields(ast);
 }
+function swapIdsOfDocumentNode(documentnode, draftFunctions) {
+    const recordNodes = findRecordSelections(documentnode);
+    recordNodes.forEach((recordConnection) => {
+        swapIdsOfFieldNode(recordConnection, draftFunctions);
+    });
+    return documentnode;
+}
+function swapIdsOfFieldNode(selectionNode, draftFunctions) {
+    if (isCustomFieldNode(selectionNode) &&
+        selectionNode.type === 'Connection' &&
+        selectionNode.arguments !== undefined &&
+        selectionNode.arguments.some((argment) => argment.name === 'where')) {
+        const swappedArguments = selectionNode.arguments.map((argument) => {
+            if (argument.name === 'where') {
+                return {
+                    ...argument,
+                    value: swapIdsOfValueNode(argument.value, draftFunctions.isDraftId, draftFunctions.getCanonicalId),
+                };
+            }
+            else {
+                return argument;
+            }
+        });
+        selectionNode.arguments = swappedArguments;
+    }
+    if (selectionNode.luvioSelections !== undefined) {
+        for (const childSelectionNode of selectionNode.luvioSelections) {
+            if (isCustomFieldNode(childSelectionNode) ||
+                isObjectFieldSelection(childSelectionNode)) {
+                swapIdsOfFieldNode(childSelectionNode, draftFunctions);
+            }
+        }
+    }
+}
+function swapIdsOfValueNode(valueNode, isDraftId, idMapper) {
+    switch (valueNode.kind) {
+        case Kind.OBJECT: {
+            const swappedObjectValueNode = {};
+            for (const key of keys(valueNode.fields)) {
+                swappedObjectValueNode[key] = swapIdsOfValueNode(valueNode.fields[key], isDraftId, idMapper);
+            }
+            return {
+                kind: 'ObjectValue',
+                fields: swappedObjectValueNode,
+            };
+        }
+        case Kind.LIST: {
+            const listValueNodes = [];
+            for (const child of valueNode.values) {
+                listValueNodes.push(swapIdsOfValueNode(child, isDraftId, idMapper));
+            }
+            return {
+                kind: 'ListValue',
+                values: listValueNodes,
+            };
+        }
+        case Kind.STRING: {
+            if (!isDraftId(valueNode.value)) {
+                return valueNode;
+            }
+            return {
+                kind: 'StringValue',
+                value: idMapper(valueNode.value),
+                block: false,
+            };
+        }
+        default:
+            return {
+                ...valueNode,
+            };
+    }
+}
 function injectScopeFields(ast) {
     const modifiedDocumentNode = {
         kind: 'Document',
@@ -76003,6 +76189,34 @@ function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext)
     }
     return buildNetworkSnapshot(luvio, config, fragment, dispatchOptions);
 }
+const replaceDraftIdsInVariables = (variables, draftFunctions) => {
+    const replace = (object) => {
+        if (typeof object === 'string') {
+            if (!draftFunctions.isDraftId(object)) {
+                return object;
+            }
+            return draftFunctions.getCanonicalId(object);
+        }
+        else if (isArray(object)) {
+            return object.map(replace);
+        }
+        else if (typeof object === 'object' && object !== null) {
+            let source = object;
+            return keys(source).reduce((acc, key) => {
+                acc[key] = replace(source[key]);
+                return acc;
+            }, {});
+        }
+        else {
+            return object;
+        }
+    };
+    let newVariables = keys(variables).reduce((acc, key) => {
+        acc[key] = replace(variables[key]);
+        return acc;
+    }, {});
+    return newVariables;
+};
 const graphQLAdapterFactory = (luvio) => {
     const uiApiGraphQLAdapter = factory$1(luvio);
     function graphql(untrustedConfig, requestContext) {
@@ -76027,9 +76241,17 @@ const graphQLAdapterFactory = (luvio) => {
             const validatedConfigWithInjection = fieldInjectionRequired
                 ? graphqlConfigWithInjectedAST(validatedConfig)
                 : validatedConfig;
-            const fragment = createFragment(luvio, validatedConfigWithInjection.query, variables);
+            const sanitizedConfig = draftFunctions !== undefined
+                ? sanitizeConfig(validatedConfigWithInjection, draftFunctions)
+                : validatedConfigWithInjection;
+            if (sanitizedConfig.variables && draftFunctions !== undefined) {
+                const variablesWithSwappedDraftIds = replaceDraftIdsInVariables(sanitizedConfig.variables, draftFunctions);
+                sanitizedConfig.variables = variablesWithSwappedDraftIds;
+                validatedConfig.variables = variablesWithSwappedDraftIds;
+            }
+            const fragment = createFragment(luvio, sanitizedConfig.query, sanitizedConfig.variables);
             const context = {
-                config: validatedConfigWithInjection,
+                config: sanitizedConfig,
                 fragment,
                 luvio,
             };
@@ -76038,7 +76260,7 @@ const graphQLAdapterFactory = (luvio) => {
                 const observers = requestContext && requestContext.eventObservers
                     ? requestContext.eventObservers
                     : [];
-                // uses the original ast to do the eval to avoid fields not needed by users
+                // uses the original ast to do the eval to avoid fields not needed by users. The draftID swapping happens when filters transform to predicates.
                 return storeEval(validatedConfig, snapshotOrPromiseFromCachePolicy, observers);
             }
             return snapshotOrPromiseFromCachePolicy;
@@ -76055,6 +76277,15 @@ function graphqlConfigWithInjectedAST(graphqlConfig) {
         query: modifiedAST,
     };
 }
+function sanitizeConfig(graphqlConfig, draftFunctions) {
+    const { query } = graphqlConfig;
+    const astCopy = parse(stringify(query));
+    const modifiedAST = swapIdsOfDocumentNode(astCopy, draftFunctions);
+    return {
+        ...graphqlConfig,
+        query: modifiedAST,
+    };
+}
 // make sure to register the configuration whenever this module loads
 register({ id: '@salesforce/lds-adapters-graphql', configuration });
 
@@ -76072,7 +76303,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.136.6-acf28210f
+// version: 1.136.8-449f5be71
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -76761,4 +76992,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, subscribeToAdapter };
-// version: 1.136.6-0f5ec3ee7
+// version: 1.136.8-1a1062e42