@salesforce/lds-worker-api 1.136.5 → 1.136.7

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

@@ -26,7 +26,7 @@
         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;
@@ -43,7 +43,7 @@
             }
         }
         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]]);
             }
@@ -304,7 +304,7 @@
         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];
@@ -575,13 +575,13 @@
             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');
@@ -677,8 +677,8 @@
             // 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();
@@ -1125,7 +1125,7 @@
             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];
@@ -1752,8 +1752,8 @@
             } 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';
@@ -1795,7 +1795,7 @@
         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];
         }
     }
@@ -2083,7 +2083,7 @@
             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`
@@ -2462,7 +2462,7 @@
             }
         }
         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];
@@ -2643,7 +2643,7 @@
             }
             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) {
@@ -2681,7 +2681,7 @@
                 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];
@@ -2692,7 +2692,7 @@
         }
         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) {
@@ -2820,7 +2820,7 @@
                 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];
@@ -3503,13 +3503,13 @@
             // 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];
@@ -3803,7 +3803,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.136.5-4301ab650
+    // version: 1.136.7-777657471
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -15227,7 +15227,7 @@
         updateReferenceMapWithKnownKey(ast, luvioDocumentNode);
         return luvioDocumentNode;
     }
-    // version: 1.136.5-4301ab650
+    // version: 1.136.7-777657471
 
     function unwrap(data) {
         // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16140,7 +16140,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.136.5-4301ab650
+    // version: 1.136.7-777657471
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -16227,7 +16227,7 @@
 
     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);
 
@@ -17065,7 +17065,7 @@
         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;
@@ -17083,7 +17083,7 @@
             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];
@@ -17091,7 +17091,7 @@
             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];
@@ -17558,7 +17558,7 @@
         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
@@ -19006,7 +19006,7 @@
     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];
@@ -19051,7 +19051,7 @@
      */
     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];
@@ -19090,7 +19090,7 @@
     }
     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];
@@ -19278,7 +19278,7 @@
                         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 {
@@ -19330,13 +19330,13 @@
         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 [];
@@ -19373,7 +19373,7 @@
     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) {
@@ -19526,8 +19526,8 @@
         }
         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;
@@ -19551,7 +19551,7 @@
         // 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) {
@@ -19684,7 +19684,7 @@
             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]);
                     }
@@ -19831,7 +19831,7 @@
         }
         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];
@@ -19943,9 +19943,9 @@
                 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++) {
@@ -20714,7 +20714,7 @@
 
     // 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;
@@ -21894,18 +21894,18 @@
         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) {
@@ -24638,7 +24638,7 @@
         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];
@@ -24657,12 +24657,12 @@
             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];
@@ -24700,19 +24700,19 @@
     }
     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];
@@ -25091,11 +25091,11 @@
     ];
     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);
@@ -40023,7 +40023,7 @@
         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) {
@@ -43907,7 +43907,7 @@
             dropFunction: instrumentation$2.notifyRecordUpdateAvailableDropped,
         });
     });
-    // version: 1.136.5-9eb467125
+    // version: 1.136.7-ae23b4cbb
 
     var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -43985,7 +43985,7 @@
     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';
 
@@ -44050,7 +44050,7 @@
     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];
@@ -44454,7 +44454,7 @@
     }
     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';
@@ -44498,7 +44498,7 @@
         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 };
@@ -44672,7 +44672,7 @@
                         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];
@@ -44700,7 +44700,7 @@
         // 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];
@@ -44722,7 +44722,7 @@
         }
         const durableStoreOperations = [];
         // publishes
-        const recordKeys = keys$5(durableRecords);
+        const recordKeys = keys$6(durableRecords);
         if (recordKeys.length > 0) {
             durableStoreOperations.push({
                 type: 'setEntries',
@@ -44731,7 +44731,7 @@
             });
         }
         // evicts
-        const evictedKeys = keys$5(evictedRecords);
+        const evictedKeys = keys$6(evictedRecords);
         if (evictedKeys.length > 0) {
             durableStoreOperations.push({
                 type: 'evictEntries',
@@ -44885,7 +44885,7 @@
                 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];
@@ -45702,6 +45702,12 @@
     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 };
     }
@@ -45961,7 +45967,7 @@
             case ComparisonOperator.eq:
                 return '=';
             case ComparisonOperator.ne:
-                return '!=';
+                return 'IS NOT';
             case ComparisonOperator.gt:
                 return '>';
             case ComparisonOperator.gte:
@@ -46472,6 +46478,9 @@
         }
     }
 
+    const { isArray: isArray$4 } = Array;
+    const { keys: keys$5 } = Object;
+
     function isListValueNode(node) {
         return node.kind === 'ListValue';
     }
@@ -46524,13 +46533,13 @@
     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), []);
@@ -46552,22 +46561,22 @@
         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) => {
@@ -46585,10 +46594,10 @@
         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.
@@ -46599,7 +46608,7 @@
      * @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}`;
@@ -46618,7 +46627,7 @@
         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;
         }
@@ -46630,7 +46639,11 @@
         });
         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]);
@@ -46640,8 +46653,9 @@
             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,
@@ -46732,7 +46746,29 @@
                     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 = {
@@ -47834,7 +47870,7 @@
         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 = [];
@@ -47996,27 +48032,19 @@
                 ? 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)
@@ -48026,6 +48054,51 @@
             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.
@@ -48044,14 +48117,43 @@
                 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
@@ -48086,7 +48188,7 @@
          * 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
@@ -48133,6 +48235,7 @@
                 astTransformResult = transform(ast, {
                     userId,
                     objectInfoMap,
+                    draftFunctions,
                 });
                 if (astTransformResult.isSuccess === false) {
                     for (const error of astTransformResult.error) {
@@ -48170,8 +48273,6 @@
         }
     }
 
-    const { isArray: isArray$4 } = Array;
-
     /**
      * Checks a GraphQL-shaped network response for errors, returning true if it does
      * and false otherwise
@@ -48217,7 +48318,7 @@
             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;
@@ -48225,7 +48326,7 @@
         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;
@@ -48244,7 +48345,7 @@
     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
@@ -48274,7 +48375,7 @@
                 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({
@@ -55860,6 +55961,19 @@
         });
     }
 
+    /**
+     * This function takes an unknown error and normalizes it to an Error object
+     */
+    function normalizeError$1(error) {
+        if (typeof error === 'object' && error instanceof Error) {
+            return error;
+        }
+        else if (typeof error === 'string') {
+            return new Error(error);
+        }
+        return new Error(stringify$2(error));
+    }
+
     const PERFORM_QUICK_ACTION_ENDPOINT_REGEX = /^\/ui-api\/actions\/perform-quick-action\/.*$/;
     /**
      * Checks if a provided resource request is a POST operation on the record
@@ -55878,7 +55992,7 @@
                 return env.dispatchResourceRequest(request, context, eventObservers);
             }
             const { data } = await handler.enqueue(request).catch((err) => {
-                throw createDraftSynthesisErrorResponse(err.message);
+                throw createDraftSynthesisErrorResponse(normalizeError$1(err).message);
             });
             if (data === undefined) {
                 return Promise.reject(createDraftSynthesisErrorResponse());
@@ -56215,7 +56329,7 @@
         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)) {
@@ -56272,7 +56386,7 @@
                     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) {
@@ -57858,7 +57972,7 @@
         }, 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;
 
@@ -57874,15 +57988,15 @@
         enqueue(handlerId, data) {
             const callProxyMethod = __nimbus.plugins.LdsDraftQueue.callProxyMethod;
             if (callProxyMethod === undefined) {
-                return Promise.reject('callProxyMethod not defined on the nimbus plugin');
+                return Promise.reject(new Error('callProxyMethod not defined on the nimbus plugin'));
             }
             const serializedAction = stringify$6([handlerId, data]);
             return new Promise((resolve, reject) => {
                 callProxyMethod('enqueue', serializedAction, (serializedActionResponse) => {
                     const response = parse$6(serializedActionResponse);
                     resolve(response);
-                }, (serializedError) => {
-                    reject(parse$6(serializedError));
+                }, (errorMessage) => {
+                    reject(new Error(errorMessage));
                 });
             });
         }
@@ -57892,18 +58006,18 @@
             return Promise.resolve;
         }
         processNextAction() {
-            return Promise.reject('Cannot call processNextAction from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call processNextAction from the NimbusDraftQueue'));
         }
         getQueueActions() {
             const callProxyMethod = __nimbus.plugins.LdsDraftQueue.callProxyMethod;
             if (callProxyMethod === undefined) {
-                return Promise.reject('callProxyMethod not defined on the nimbus plugin');
+                return Promise.reject(new Error('callProxyMethod not defined on the nimbus plugin'));
             }
             return new Promise((resolve, reject) => {
                 callProxyMethod('getQueueActions', stringify$6([]), (serializedQueue) => {
                     resolve(parse$6(serializedQueue));
-                }, (serializedError) => {
-                    reject(parse$6(serializedError));
+                }, (errorMessage) => {
+                    reject(new Error(errorMessage));
                 });
             });
         }
@@ -57931,32 +58045,32 @@
             throw new Error('Cannot call getQueueState from the NimbusDraftQueue');
         }
         removeDraftAction(_actionId) {
-            return Promise.reject('Cannot call removeDraftAction from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call removeDraftAction from the NimbusDraftQueue'));
         }
         startQueue() {
-            return Promise.reject('Cannot call startQueue from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call startQueue from the NimbusDraftQueue'));
         }
         stopQueue() {
-            return Promise.reject('Cannot call stopQueue from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call stopQueue from the NimbusDraftQueue'));
         }
         replaceAction(_actionId, _withActionId) {
-            return Promise.reject('Cannot call replaceAction from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call replaceAction from the NimbusDraftQueue'));
         }
         mergeActions(_targetActionId, _sourceActionId) {
-            return Promise.reject('Cannot call mergeActions from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call mergeActions from the NimbusDraftQueue'));
         }
         setMetadata(_actionId, _metadata) {
-            return Promise.reject('Cannot call setMetadata from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call setMetadata from the NimbusDraftQueue'));
         }
         addHandler(_handler) {
             // no-op -- all registration occurs against concrete draft queue
             return Promise.resolve();
         }
         addCustomHandler(_id, _executor) {
-            return Promise.reject('Cannot call setMetadata from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call setMetadata from the NimbusDraftQueue'));
         }
         removeHandler(_id) {
-            return Promise.reject('Cannot call setMetadata from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call setMetadata from the NimbusDraftQueue'));
         }
     }
 
@@ -57979,7 +58093,7 @@
      * @param err Unknown object to sanitize
      * @returns an instance of error
      */
-    function normalizeError$1(err) {
+    function normalizeError$2(err) {
         if (err instanceof Error) {
             return err;
         }
@@ -57991,13 +58105,13 @@
     const DRAFT_QUEUE_TOTAL_MERGE_ACTIONS_CALLS = 'draft-queue-total-mergeActions-calls';
     const DRAFT_AWARE_CREATE_CONTENT_DOCUMENT_AND_VERSION_ERROR = 'draft-aware-create-content-document-and-version-error';
     function reportGraphqlQueryParseError(err) {
-        normalizeError$1(err);
+        normalizeError$2(err);
     }
     function reportGraphqlSqlEvalPreconditionError(err) {
-        normalizeError$1(err);
+        normalizeError$2(err);
     }
     function reportGraphqlCreateSnapshotError(err) {
-        normalizeError$1(err);
+        normalizeError$2(err);
     }
     function reportGraphQlEvalDbReadDuration(duration) {
     }
@@ -58007,7 +58121,7 @@
             error = err.body;
         }
         else {
-            error = normalizeError$1(err);
+            error = normalizeError$2(err);
         }
         const errorCode = DRAFT_AWARE_CREATE_CONTENT_DOCUMENT_AND_VERSION_ERROR;
         const errorType = error.errorType;
@@ -58036,7 +58150,7 @@
         const { tags, metricName, logError } = config;
         return operation()
             .catch((err) => {
-            const error = normalizeError$1(err);
+            const error = normalizeError$2(err);
             tags['errorMessage'] = error.message;
             throw err;
         })
@@ -58418,7 +58532,7 @@
                 },
                 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];
@@ -58479,7 +58593,7 @@
                 },
                 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;
@@ -58564,7 +58678,7 @@
                 },
                 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)];
@@ -59428,11 +59542,6 @@
             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;
@@ -59471,6 +59580,20 @@
             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) => {
@@ -59520,7 +59643,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$1,
     });
-    // version: 1.136.5-4301ab650
+    // version: 1.136.7-777657471
 
     const { create: create$2, keys: keys$2 } = Object;
     const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -73954,7 +74077,7 @@
         configuration: { ...configurationForGraphQLAdapters },
         instrument,
     });
-    // version: 1.136.5-9eb467125
+    // version: 1.136.7-ae23b4cbb
 
     // On core the unstable adapters are re-exported with different names,
 
@@ -75326,10 +75449,14 @@
     }
 
     let storeEval = undefined;
+    let draftFunctions = undefined;
     const configuration = {
         setStoreEval: function (storeEvalArg) {
             storeEval = storeEvalArg;
         },
+        setDraftFunctions: function (draftFuncs) {
+            draftFunctions = draftFuncs;
+        },
     };
 
     const assignedToMe = {
@@ -75415,6 +75542,78 @@
     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',
@@ -75996,6 +76195,34 @@
         }
         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) {
@@ -76020,9 +76247,17 @@
                 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,
                 };
@@ -76031,7 +76266,7 @@
                     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;
@@ -76048,6 +76283,15 @@
             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 });
 
@@ -76065,7 +76309,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.136.5-9eb467125
+    // version: 1.136.7-ae23b4cbb
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -76675,24 +76919,21 @@
      * to the instance of the lds-drafts' DraftQueue implementation
      */
     const nimbusDraftQueue = {
-        callProxyMethod(methodName, serializedArgsArray, resultCallback, errorCallback) {
+        callProxyMethod(methodName, serializedArgsArray, resultCallback, 
+        // NOTE: the other side of the proxy is expecting an error message string
+        // (not a JSON serialized Error object)
+        errorCallback) {
             const method = draftQueue[methodName];
             if (method === undefined) {
-                return errorCallback(stringify$1({
-                    message: 'Method does not exist on the draft queue',
-                }));
+                return errorCallback('Method does not exist on the draft queue');
             }
             if (allowList.includes(methodName) === false) {
-                return errorCallback(stringify$1({
-                    message: `Method ${methodName} is not available for proxy invocation`,
-                }));
+                return errorCallback(`Method ${methodName} is not available for proxy invocation`);
             }
             const parsedArgs = parse$1(serializedArgsArray);
             // TODO [W-9933226]: we should validate the argument list based on which method is being called
             if (isArray$1(parsedArgs) === false) {
-                return errorCallback(stringify$1({
-                    message: 'expected array argument list',
-                }));
+                return errorCallback('expected array argument list');
             }
             let methodResult = undefined;
             try {
@@ -76704,7 +76945,7 @@
                 }
             }
             catch (err) {
-                return errorCallback(stringify$1(err));
+                return errorCallback(normalizeError(err).message);
             }
             if (methodResult.then === undefined) {
                 return resultCallback(stringify$1(methodResult));
@@ -76714,7 +76955,7 @@
                 resultCallback(stringify$1(result));
             })
                 .catch((err) => {
-                errorCallback(stringify$1(err));
+                errorCallback(normalizeError(err).message);
             });
         },
     };
@@ -76774,4 +77015,4 @@
     Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-// version: 1.136.5-4301ab650
+// version: 1.136.7-777657471