@salesforce/lds-worker-api 1.296.1 → 1.297.0

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

@@ -26,7 +26,7 @@
         SnapshotState["Stale"] = "Stale";
     })(SnapshotState$3 || (SnapshotState$3 = {}));
 
-    const { create: create$b, entries: entries$6, freeze: freeze$6, keys: keys$c, values: values$5, assign: assign$a } = Object;
+    const { create: create$c, entries: entries$7, freeze: freeze$6, keys: keys$d, values: values$6, assign: assign$b } = Object;
     const { hasOwnProperty: hasOwnProperty$3 } = Object.prototype;
     const { isArray: isArray$9 } = Array;
     const { push: push$5, indexOf, slice: slice$2 } = Array.prototype;
@@ -54,7 +54,7 @@
             }
         }
         else {
-            const keys$1 = keys$c(value);
+            const keys$1 = keys$d(value);
             for (let i = 0, len = keys$1.length; i < len; i += 1) {
                 deepFreeze(value[keys$1[i]]);
             }
@@ -325,7 +325,7 @@
         if (node === null) {
             return 'null';
         }
-        const keys$1 = keys$c(node).sort();
+        const keys$1 = keys$d(node).sort();
         out = '';
         for (i = 0; i < keys$1.length; i++) {
             const key = keys$1[i];
@@ -593,13 +593,13 @@
     class StringKeyInMemoryStore {
         constructor(options = {}) {
             // public, in memory properties
-            this.records = create$b(null);
-            this.metadata = create$b(null);
-            this.visitedIds = create$b(null);
-            this.refreshedIds = create$b(null);
-            this.redirectKeys = create$b(null);
-            this.retainedIds = create$b(null);
-            this.ttlOverrides = create$b(null);
+            this.records = create$c(null);
+            this.metadata = create$c(null);
+            this.visitedIds = create$c(null);
+            this.refreshedIds = create$c(null);
+            this.redirectKeys = create$c(null);
+            this.retainedIds = create$c(null);
+            this.ttlOverrides = create$c(null);
             this.snapshotSubscriptions = [];
             this.trimTask = null;
             this.pendingTrimKeys = new Set();
@@ -607,8 +607,8 @@
             this.watchSubscriptions = [];
             this.eventObservers = [];
             // private/protected
-            this.insertedIds = create$b(null);
-            this.reverseRedirectKeys = create$b(null);
+            this.insertedIds = create$c(null);
+            this.reverseRedirectKeys = create$c(null);
             this.currentSnapshotId = 0;
             this.scheduler = options.scheduler || buildDefaultScheduler();
             if (options.initialData) {
@@ -621,13 +621,13 @@
             return this.records[this.getCanonicalRecordId(key)];
         }
         getNumEntries() {
-            return keys$c(this.records).length;
+            return keys$d(this.records).length;
         }
         readMetadata(key) {
             return this.metadata[this.getCanonicalRecordId(key)];
         }
         readMetadataWhere(query) {
-            const keys$1 = keys$c(this.metadata);
+            const keys$1 = keys$d(this.metadata);
             const results = [];
             const hasNamespaceQuery = hasOwnProperty$3.call(query, 'namespace');
             const hasRepresentationNameQuery = hasOwnProperty$3.call(query, 'representationName');
@@ -724,8 +724,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$c(visitedIds);
-            const allRefreshedIds = keys$c(refreshedIds);
+            const allVisitedIds = keys$d(visitedIds);
+            const allRefreshedIds = keys$d(refreshedIds);
             // Early exit if nothing has changed
             if (allVisitedIds.length === 0 && allRefreshedIds.length === 0) {
                 return Promise.resolve();
@@ -768,9 +768,9 @@
                     callback(watchCallbackEntries);
                 }
             }
-            this.visitedIds = create$b(null);
-            this.refreshedIds = create$b(null);
-            this.insertedIds = create$b(null);
+            this.visitedIds = create$c(null);
+            this.refreshedIds = create$c(null);
+            this.insertedIds = create$c(null);
             // the .then removes the return of an array of voids to a single void
             return Promise.all(snapshotSubPromises).then(() => { });
         }
@@ -959,18 +959,18 @@
             return this.defaultTTLOverride;
         }
         reset() {
-            this.records = create$b(null);
+            this.records = create$c(null);
             this.snapshotSubscriptions = [];
             this.watchSubscriptions = [];
-            this.visitedIds = create$b(null);
-            this.refreshedIds = create$b(null);
-            this.insertedIds = create$b(null);
-            this.redirectKeys = create$b(null);
-            this.reverseRedirectKeys = create$b(null);
-            this.retainedIds = create$b(null);
-            this.ttlOverrides = create$b(null);
+            this.visitedIds = create$c(null);
+            this.refreshedIds = create$c(null);
+            this.insertedIds = create$c(null);
+            this.redirectKeys = create$c(null);
+            this.reverseRedirectKeys = create$c(null);
+            this.retainedIds = create$c(null);
+            this.ttlOverrides = create$c(null);
             this.trimTask = null;
-            this.metadata = create$b(null);
+            this.metadata = create$c(null);
             this.defaultTTLOverride = undefined;
             emitLuvioStoreEvent({ type: 'store-reset', timestamp: Date.now() }, this.eventObservers);
         }
@@ -1229,7 +1229,7 @@
         calculateAndSetNewTTLs(storeMetadata, resetInitialDataTtls) {
             if (resetInitialDataTtls === true) {
                 const now = Date.now();
-                keys$c(storeMetadata).forEach((key) => {
+                keys$d(storeMetadata).forEach((key) => {
                     const storeMetadataEntry = storeMetadata[key];
                     const ttl = storeMetadataEntry.expirationTimestamp - storeMetadataEntry.ingestionTimestamp;
                     storeMetadataEntry.ingestionTimestamp = now;
@@ -1258,7 +1258,7 @@
             hasOverlappingIds(snapshot, visitedIds) === false);
     }
     function getMatchingIds(partialKey, visitedIds) {
-        const keys$1 = keys$c(partialKey);
+        const keys$1 = keys$d(partialKey);
         return visitedIds.filter((visitedId) => {
             return keys$1.every((key) => {
                 return partialKey[key] === visitedId[key];
@@ -1908,8 +1908,8 @@
             } while (redirectKey !== undefined);
         }
         isUsingStringKeys() {
-            return (keys$c(this.fallbackStringKeyInMemoryStore.visitedIds).length !== 0 ||
-                keys$c(this.fallbackStringKeyInMemoryStore.refreshedIds).length !== 0);
+            return (keys$d(this.fallbackStringKeyInMemoryStore.visitedIds).length !== 0 ||
+                keys$d(this.fallbackStringKeyInMemoryStore.refreshedIds).length !== 0);
         }
         delegateToFallbackStringKeyStore(snapshot) {
             return !isErrorSnapshot$3(snapshot) && typeof snapshot.recordId === 'string';
@@ -1951,7 +1951,7 @@
         buildKeySchema(keyMetadata) {
             // pull NamespacedType type out of NormalizedKeyMetadata
             const { namespace: _ns, representationName: _rn, ...keyParamValues } = keyMetadata;
-            const keySchema = keys$c(keyParamValues).sort();
+            const keySchema = keys$d(keyParamValues).sort();
             return ['namespace', 'representationName', ...keySchema];
         }
         serialize() {
@@ -2245,7 +2245,7 @@
             return value;
         }
         keys() {
-            return keys$c(this.data);
+            return keys$d(this.data);
         }
         isScalar(propertyName) {
             // TODO W-6900046 - merge.ts casts these to any and manually sets `data`
@@ -2666,7 +2666,7 @@
             }
         }
         selectAllObject(record, data, visitedKeys) {
-            const recordKeys = keys$c(record);
+            const recordKeys = keys$d(record);
             const { length } = recordKeys;
             for (let i = 0; i < length; i += 1) {
                 const key = recordKeys[i];
@@ -2850,7 +2850,7 @@
             }
             const { baseSnapshotValue } = this.currentPath;
             if (isDefined$1(baseSnapshotValue)) {
-                this.snapshotChanged = keys$1.length !== keys$c(baseSnapshotValue).length;
+                this.snapshotChanged = keys$1.length !== keys$d(baseSnapshotValue).length;
             }
         }
         checkIfChanged(value, options) {
@@ -2894,7 +2894,7 @@
                 return this.markMissing();
             }
             const sink = (data[propertyName] = {});
-            const keys$1 = keys$c(obj);
+            const keys$1 = keys$d(obj);
             this.checkIfObjectKeysLengthChanged(keys$1);
             for (let i = 0, len = keys$1.length; i < len; i += 1) {
                 const key = keys$1[i];
@@ -2905,7 +2905,7 @@
         }
         readLinkMap(propertyName, selection, record, data) {
             const map = record[propertyName];
-            const keys$1 = keys$c(map);
+            const keys$1 = keys$d(map);
             const sink = {};
             this.checkIfObjectKeysLengthChanged(keys$1);
             for (let i = 0, len = keys$1.length; i < len; i += 1) {
@@ -3039,7 +3039,7 @@
                 return;
             }
             const sink = (data[propertyName] = {});
-            const keys$1 = keys$c(obj);
+            const keys$1 = keys$d(obj);
             this.checkIfObjectKeysLengthChanged(keys$1);
             for (let i = 0, len = keys$1.length; i < len; i += 1) {
                 const key = keys$1[i];
@@ -3272,8 +3272,8 @@
             this.defaultCachePolicy = { type: 'cache-then-network' };
             this.store = store;
             this.networkAdapter = networkAdapter;
-            this.adapterContextMap = create$b(null);
-            this.typeQueryEvaluatorMap = create$b(null);
+            this.adapterContextMap = create$c(null);
+            this.typeQueryEvaluatorMap = create$c(null);
             // bind these methods so when they get passed into the
             // Store, the this reference is preserved
             this.createSnapshot = this.createSnapshot.bind(this);
@@ -3473,7 +3473,7 @@
             // retrieve from adapterContextMap if contextId is supplied
             // we will only track context of adapters that explicitly provide a contextId
             if (this.adapterContextMap[contextId] === undefined) {
-                this.adapterContextMap[contextId] = create$b(null);
+                this.adapterContextMap[contextId] = create$c(null);
             }
             const contextStore = this.adapterContextMap[contextId];
             const context = {
@@ -3735,13 +3735,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$c(queryParams)) {
+            for (const paramKey of keys$d(queryParams)) {
                 const value = queryParams[paramKey];
                 if (value === undefined) {
                     delete queryParams[paramKey];
                 }
             }
-            for (const paramKey of keys$c(urlParams)) {
+            for (const paramKey of keys$d(urlParams)) {
                 const value = urlParams[paramKey];
                 if (value === undefined) {
                     delete urlParams[paramKey];
@@ -4068,16 +4068,16 @@
             return acc;
         }, {});
         const resourceParams = {};
-        if (keys$c(urlParams).length > 0) {
+        if (keys$d(urlParams).length > 0) {
             resourceParams[CONFIG_PROPERTY_URL_PARAMS] = urlParams;
         }
-        if (keys$c(queryParams).length > 0) {
+        if (keys$d(queryParams).length > 0) {
             resourceParams[CONFIG_PROPERTY_QUERY_PARAMS] = queryParams;
         }
         if (bodyParams.length > 0) {
             resourceParams[CONFIG_PROPERTY_BODY] = actualBodyParams;
         }
-        if (keys$c(headerParams).length > 0) {
+        if (keys$d(headerParams).length > 0) {
             resourceParams[CONFIG_PROPERTY_HEADERS] = headerParams;
         }
         return resourceParams;
@@ -4210,7 +4210,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.296.1-1aa7fc7e3
+    // version: 1.297.0-1fc775982
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -15718,7 +15718,7 @@
         }
         return superResult;
     }
-    // version: 1.296.1-1aa7fc7e3
+    // version: 1.297.0-1fc775982
 
     function unwrap(data) {
         // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16308,7 +16308,7 @@
         return factory(luvio);
     }
 
-    const { create: create$a, defineProperty, defineProperties } = Object;
+    const { create: create$b, defineProperty, defineProperties } = Object;
 
     var SnapshotState$2;
     (function (SnapshotState) {
@@ -16647,7 +16647,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.296.1-1aa7fc7e3
+    // version: 1.297.0-1fc775982
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -16750,7 +16750,7 @@
 
     const { keys: ObjectKeys$3, create: ObjectCreate$3 } = Object;
 
-    const { assign: assign$9, create: create$9, freeze: freeze$5, isFrozen: isFrozen$3, keys: keys$b } = Object;
+    const { assign: assign$a, create: create$a, freeze: freeze$5, isFrozen: isFrozen$3, keys: keys$c } = Object;
 
     ObjectCreate$3(null);
 
@@ -17207,7 +17207,7 @@
     }
     const keyPrefix$2 = 'UiApi';
 
-    const { assign: assign$8, create: create$8, freeze: freeze$4, isFrozen: isFrozen$2, keys: keys$a } = Object;
+    const { assign: assign$9, create: create$9, freeze: freeze$4, isFrozen: isFrozen$2, keys: keys$b } = Object;
     const { hasOwnProperty: hasOwnProperty$1 } = Object.prototype;
     const { split, endsWith } = String.prototype;
     const { isArray: isArray$7 } = Array;
@@ -17236,7 +17236,7 @@
         for (let i = 0, len = value.length; i < len; i += 1) {
             result[value[i]] = true;
         }
-        return keys$a(result);
+        return keys$b(result);
     }
     /**
      * @param source The array of string to filter
@@ -18091,14 +18091,14 @@
             mergeable: true,
         });
         const input_childRelationships = input.childRelationships;
-        const input_childRelationships_keys = keys$a(input_childRelationships);
+        const input_childRelationships_keys = keys$b(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];
             getTypeCacheKeys$V$1(rootKeySet, luvio, input_childRelationships[key], () => rootKey + '__childRelationships' + '__' + key);
         }
         const input_fields = input.fields;
-        const input_fields_keys = keys$a(input_fields);
+        const input_fields_keys = keys$b(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];
@@ -20015,7 +20015,7 @@
     function createPathSelection(propertyName, fieldDefinition) {
         const fieldsSelection = [];
         const { children } = fieldDefinition;
-        const childrenKeys = keys$a(children);
+        const childrenKeys = keys$b(children);
         for (let i = 0, len = childrenKeys.length; i < len; i += 1) {
             const childKey = childrenKeys[i];
             const childFieldDefinition = children[childKey];
@@ -20060,7 +20060,7 @@
      */
     function createPathSelectionFromValue(fields) {
         const fieldsSelection = [];
-        const fieldNames = keys$a(fields);
+        const fieldNames = keys$b(fields);
         for (let i = 0, len = fieldNames.length; i < len; i++) {
             const fieldName = fieldNames[i];
             const { value: fieldValue } = fields[fieldName];
@@ -20099,7 +20099,7 @@
     }
     function extractRecordFieldsRecursively(record) {
         const fields = [];
-        const fieldNames = keys$a(record.fields);
+        const fieldNames = keys$b(record.fields);
         for (let i = 0, len = fieldNames.length; i < len; i++) {
             const fieldName = fieldNames[i];
             const { value: fieldValue } = record.fields[fieldName];
@@ -20290,7 +20290,7 @@
                     // For a spanning record that is detected to be a circular reference, we add the field along with Id and Name.
                     // It's possible for spanning record lookup fields to sometimes be circular, and sometimes not - depending on the value of the lookup field.
                     // For more information on scenarios that caused this fix: search "LDS Recursive Spanning Fields Problem" in Quip
-                    if (keys$a(next.children).length === 0) {
+                    if (keys$b(next.children).length === 0) {
                         addScalarFieldId(next);
                         addScalarFieldName(next);
                     }
@@ -20341,13 +20341,13 @@
         return endsWith.call(spanningNode.scalar('apiName'), CUSTOM_EXTERNAL_OBJECT_FIELD_SUFFIX);
     }
     function convertTrieToFields(root) {
-        if (keys$a(root.children).length === 0) {
+        if (keys$b(root.children).length === 0) {
             return [];
         }
         return convertTrieToFieldsRecursively(root);
     }
     function convertTrieToFieldsRecursively(root) {
-        const childKeys = keys$a(root.children);
+        const childKeys = keys$b(root.children);
         if (childKeys.length === 0) {
             if (root.name === '') {
                 return [];
@@ -20384,7 +20384,7 @@
     function mergeFieldsTries(rootA, rootB) {
         const rootAchildren = rootA.children;
         const rootBchildren = rootB.children;
-        const childBKeys = keys$a(rootBchildren);
+        const childBKeys = keys$b(rootBchildren);
         for (let i = 0, len = childBKeys.length; i < len; i++) {
             const childBKey = childBKeys[i];
             if (rootAchildren[childBKey] === undefined) {
@@ -20544,8 +20544,8 @@
         }
         const childrenA = a.children;
         const childrenB = b.children;
-        const childKeysA = keys$a(childrenA);
-        const childKeysB = keys$a(childrenB);
+        const childKeysA = keys$b(childrenA);
+        const childKeysB = keys$b(childrenB);
         const childKeysBLength = childKeysB.length;
         if (childKeysBLength > childKeysA.length) {
             return false;
@@ -20589,7 +20589,7 @@
         // RecordRepresentationNormalized['fields'] to include `pending:true` property
         const mergedFields = { ...newRecord.fields };
         const merged = { ...newRecord, fields: mergedFields };
-        const existingFields = keys$a(oldRecord.fields);
+        const existingFields = keys$b(oldRecord.fields);
         for (let i = 0, len = existingFields.length; i < len; i += 1) {
             const spanningFieldName = existingFields[i];
             if (newRecord.fields[spanningFieldName] === undefined) {
@@ -20722,7 +20722,7 @@
             if (isGraphNode(node)) {
                 const dependencies = node.retrieve();
                 if (dependencies !== null) {
-                    const depKeys = keys$a(dependencies);
+                    const depKeys = keys$b(dependencies);
                     for (let i = 0, len = depKeys.length; i < len; i++) {
                         luvio.storeEvict(depKeys[i]);
                     }
@@ -20869,7 +20869,7 @@
         }
         for (let i = 0; i < fieldSubtries.length; i++) {
             const subtrie = fieldSubtries[i];
-            const fieldNames = keys$a(subtrie.children);
+            const fieldNames = keys$b(subtrie.children);
             for (let i = 0; i < fieldNames.length; i++) {
                 const fieldName = fieldNames[i];
                 const childTrie = subtrie.children[fieldName];
@@ -20983,9 +20983,9 @@
                 return false;
             }
         }
-        const headersKeys = keys$a(headers);
+        const headersKeys = keys$b(headers);
         const headersKeyLength = headersKeys.length;
-        if (headersKeyLength !== keys$a(existingHeaders).length) {
+        if (headersKeyLength !== keys$b(existingHeaders).length) {
             return false;
         }
         for (let i = 0, len = headersKeyLength; i < len; i++) {
@@ -21593,7 +21593,7 @@
 
     // iterate through the map to build configs for network calls
     function resolveConflict(luvio, map) {
-        const ids = keys$a(map.conflicts);
+        const ids = keys$b(map.conflicts);
         if (ids.length === 0) {
             instrumentation$3.recordConflictsResolved(map.serverRequestCount);
             return;
@@ -23045,18 +23045,18 @@
         return {
             getRecordSelectionFieldSets() {
                 const optionalPlusDefaultFields = { ...optionalFields_ };
-                const fields = keys$a(defaultFields_);
+                const fields = keys$b(defaultFields_);
                 for (let i = 0; i < fields.length; ++i) {
                     const field = fields[i];
                     if (!fields_[field] && !defaultServerFieldStatus.missingFields[field]) {
                         optionalPlusDefaultFields[field] = true;
                     }
                 }
-                return [keys$a(fields_).sort(), keys$a(optionalPlusDefaultFields).sort()];
+                return [keys$b(fields_).sort(), keys$b(optionalPlusDefaultFields).sort()];
             },
             processRecords(records) {
                 const { missingFields } = defaultServerFieldStatus;
-                const fields = keys$a(missingFields);
+                const fields = keys$b(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) {
@@ -25511,7 +25511,7 @@
         const lookupFields = {};
         const { apiName, fields: recordFields } = record;
         const { fields: objectInfoFields } = objectInfo;
-        const objectInfoFieldNames = keys$a(objectInfoFields);
+        const objectInfoFieldNames = keys$b(objectInfoFields);
         for (let i = 0, len = objectInfoFieldNames.length; i < len; i += 1) {
             const fieldName = objectInfoFieldNames[i];
             const field = objectInfoFields[fieldName];
@@ -25530,12 +25530,12 @@
             const nameField = `${apiName}.${relationshipName}.${getNameField(objectInfo, fieldName)}`;
             lookupFields[nameField] = true;
         }
-        return keys$a(lookupFields);
+        return keys$b(lookupFields);
     }
     function getRecordUiMissingRecordLookupFields(recordUi) {
         const { records, objectInfos } = recordUi;
         const recordLookupFields = {};
-        const recordIds = keys$a(records);
+        const recordIds = keys$b(records);
         for (let i = 0, len = recordIds.length; i < len; i += 1) {
             const recordId = recordIds[i];
             const recordData = records[recordId];
@@ -25573,19 +25573,19 @@
     }
     function eachLayout(recordUi, cb) {
         const { layouts } = recordUi;
-        const layoutApiNames = keys$a(layouts);
+        const layoutApiNames = keys$b(layouts);
         for (let a = 0, len = layoutApiNames.length; a < len; a += 1) {
             const apiName = layoutApiNames[a];
             const apiNameData = layouts[apiName];
-            const recordTypeIds = keys$a(apiNameData);
+            const recordTypeIds = keys$b(apiNameData);
             for (let b = 0, recordTypeIdsLen = recordTypeIds.length; b < recordTypeIdsLen; b += 1) {
                 const recordTypeId = recordTypeIds[b];
                 const recordTypeData = apiNameData[recordTypeId];
-                const layoutTypes = keys$a(recordTypeData);
+                const layoutTypes = keys$b(recordTypeData);
                 for (let c = 0, layoutTypesLen = layoutTypes.length; c < layoutTypesLen; c += 1) {
                     const layoutType = layoutTypes[c];
                     const layoutTypeData = recordTypeData[layoutType];
-                    const modes = keys$a(layoutTypeData);
+                    const modes = keys$b(layoutTypeData);
                     for (let d = 0, modesLen = modes.length; d < modesLen; d += 1) {
                         const mode = modes[d];
                         const layout = layoutTypeData[mode];
@@ -25791,14 +25791,14 @@
     function publishDependencies(luvio, recordIds, depKeys) {
         for (let i = 0, len = recordIds.length; i < len; i += 1) {
             const recordDepKey = dependencyKeyBuilder({ recordId: recordIds[i] });
-            const dependencies = create$8(null);
+            const dependencies = create$9(null);
             for (let j = 0, len = depKeys.length; j < len; j++) {
                 dependencies[depKeys[j]] = true;
             }
             const node = luvio.getNode(recordDepKey);
             if (isGraphNode(node)) {
                 const recordDeps = node.retrieve();
-                assign$8(dependencies, recordDeps);
+                assign$9(dependencies, recordDeps);
             }
             luvio.storePublish(recordDepKey, dependencies);
         }
@@ -25982,11 +25982,11 @@
     ];
     function getFieldsFromLayoutMap(layoutMap, objectInfo) {
         let fields = [];
-        const layoutTypes = keys$a(layoutMap);
+        const layoutTypes = keys$b(layoutMap);
         for (let i = 0, layoutTypesLen = layoutTypes.length; i < layoutTypesLen; i += 1) {
             const layoutType = layoutTypes[i];
             const modesMap = layoutMap[layoutType];
-            const modes = keys$a(modesMap);
+            const modes = keys$b(modesMap);
             for (let m = 0, modesLen = modes.length; m < modesLen; m += 1) {
                 const mode = modes[m];
                 const modeKeys = getQualifiedFieldApiNamesFromLayout(modesMap[mode], objectInfo);
@@ -26015,7 +26015,7 @@
         return getRecord$1(luvio, refresh, recordId, [], implicitFields);
     }
     function getRecordForNonLayoutableEntities(luvio, adapterContext, refresh, recordId, objectInfo, configOptionalFields, configFields) {
-        const fields = keys$a(configFields ? configFields : {}).map((key) => `${objectInfo.apiName}.${key}`);
+        const fields = keys$b(configFields ? configFields : {}).map((key) => `${objectInfo.apiName}.${key}`);
         // W-12697744
         // Set the implicit fields received from the server in adapter context
         // This ensures that the implicit fields are available when data is read locally or from durable store
@@ -26254,7 +26254,7 @@
                 }
                 const { layoutType, mode, snapshot } = container;
                 if (wrapper.layoutMap[layoutType] === undefined) {
-                    wrapper.layoutMap = assign$8({}, wrapper.layoutMap, {
+                    wrapper.layoutMap = assign$9({}, wrapper.layoutMap, {
                         [layoutType]: {},
                     });
                 }
@@ -35573,7 +35573,7 @@
                 }
             }
             if (records.length > 0) {
-                assign$8(config, { records });
+                assign$9(config, { records });
             }
         }
         return config;
@@ -40715,7 +40715,7 @@
         let clonedLayoutUserStateSections;
         const { sectionUserStates } = layoutUserStateInput;
         const { sectionUserStates: cachedSectionUserStates } = cachedLayoutUserState;
-        const sectionUserStateKeys = keys$a(sectionUserStates);
+        const sectionUserStateKeys = keys$b(sectionUserStates);
         for (let i = 0, len = sectionUserStateKeys.length; i < len; i += 1) {
             const sectionId = sectionUserStateKeys[i];
             if (cachedSectionUserStates[sectionId] === undefined) {
@@ -44244,7 +44244,7 @@
         throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
         throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
     });
-    // version: 1.296.1-cf86708a0
+    // version: 1.297.0-e0cfbd880
 
     var ldsIdempotencyWriteDisabled = {
         isOpen: function (e) {
@@ -44420,7 +44420,7 @@
     const { parse: parse$6, stringify: stringify$6 } = JSON;
     const { join: join$2, push: push$2, unshift } = Array.prototype;
     const { isArray: isArray$5 } = Array;
-    const { entries: entries$5, keys: keys$8 } = Object;
+    const { entries: entries$6, keys: keys$9 } = Object;
 
     const UI_API_BASE_URI = '/services/data/v62.0/ui-api';
 
@@ -44485,7 +44485,7 @@
     function mergeRecordFields$1(first, second) {
         const { fields: targetFields } = first;
         const { fields: sourceFields } = second;
-        const fieldNames = keys$8(sourceFields);
+        const fieldNames = keys$9(sourceFields);
         for (let i = 0, len = fieldNames.length; i < len; i += 1) {
             const fieldName = fieldNames[i];
             const sourceField = sourceFields[fieldName];
@@ -44727,7 +44727,7 @@
         if (fulfill === undefined) {
             return null;
         }
-        const handlersMap = entries$5(inflightRequests);
+        const handlersMap = entries$6(inflightRequests);
         for (let i = 0, len = handlersMap.length; i < len; i += 1) {
             const [transactionKey, handlers] = handlersMap[i];
             // check fulfillment against only the first handler ([0]) because it's equal or
@@ -44892,7 +44892,7 @@
     const MessagingDurableSegment = 'MESSAGING';
     const MessageNotifyStoreUpdateAvailable = 'notifyStoreUpdateAvailable';
 
-    const { keys: keys$7, create: create$6, assign: assign$6, freeze: freeze$1$1 } = Object;
+    const { keys: keys$8, create: create$7, assign: assign$7, freeze: freeze$2$1 } = Object;
 
     //Durable store error instrumentation key
     const DURABLE_STORE_ERROR = 'durable-store-error';
@@ -44939,7 +44939,7 @@
         if (durableRecords === undefined) {
             return { revivedKeys, hadUnexpectedShape };
         }
-        const durableKeys = keys$7(durableRecords);
+        const durableKeys = keys$8(durableRecords);
         if (durableKeys.length === 0) {
             // no records to revive
             return { revivedKeys, hadUnexpectedShape };
@@ -45124,7 +45124,7 @@
                         overrides,
                     };
                 }
-                const keys$1 = keys$7(entries);
+                const keys$1 = keys$8(entries);
                 for (let i = 0, len = keys$1.length; i < len; i++) {
                     const key = keys$1[i];
                     const entry = entries[key];
@@ -45146,14 +45146,14 @@
     }
 
     function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler, redirects, additionalDurableStoreOperations = [], enableDurableMetadataRefresh = false) {
-        const durableRecords = create$6(null);
-        const refreshedDurableRecords = create$6(null);
-        const evictedRecords = create$6(null);
+        const durableRecords = create$7(null);
+        const refreshedDurableRecords = create$7(null);
+        const evictedRecords = create$7(null);
         const { visitedIds, refreshedIds } = store.fallbackStringKeyInMemoryStore;
         // 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$7({ ...visitedIds, ...refreshedIds });
+        const keys$1 = keys$8({ ...visitedIds, ...refreshedIds });
         for (let i = 0, len = keys$1.length; i < len; i += 1) {
             const key = keys$1[i];
             const canonicalKey = store.getCanonicalRecordId(key);
@@ -45176,7 +45176,7 @@
             setRecordTo(entries, key, record, metadata);
         }
         const durableStoreOperations = additionalDurableStoreOperations;
-        const recordKeys = keys$7(durableRecords);
+        const recordKeys = keys$8(durableRecords);
         if (recordKeys.length > 0) {
             // publishes with data
             durableStoreOperations.push({
@@ -45185,7 +45185,7 @@
                 segment: DefaultDurableSegment,
             });
         }
-        const refreshKeys = keys$7(refreshedDurableRecords);
+        const refreshKeys = keys$8(refreshedDurableRecords);
         if (refreshKeys.length > 0) {
             // publishes with only metadata updates
             durableStoreOperations.push({
@@ -45207,7 +45207,7 @@
             });
         });
         // evicts
-        const evictedKeys = keys$7(evictedRecords);
+        const evictedKeys = keys$8(evictedRecords);
         if (evictedKeys.length > 0) {
             durableStoreOperations.push({
                 type: 'evictEntries',
@@ -45311,7 +45311,7 @@
         // A reviving store is only "active" during a call to `environment.storeLookup`, and will
         // be used by the reader attempting to build an L1 snapshot. Immediately after the L1 rebuild
         // the reviving store becomes inactive other than receiving change notifications.
-        return create$6(upstreamStore, {
+        return create$7(upstreamStore, {
             readEntry: { value: readEntry },
             markStale: { value: markStale },
             clearStale: { value: clearStale },
@@ -45323,7 +45323,7 @@
     const ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
     async function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded) {
         // initialize empty context store
-        contextStores[adapterId] = create$6(null);
+        contextStores[adapterId] = create$7(null);
         const context = {
             set(key, value) {
                 contextStores[adapterId][key] = value;
@@ -45388,7 +45388,7 @@
         const revivingStores = new Set();
         // redirects that need to be flushed to the durable store
         const pendingStoreRedirects = new Map();
-        const contextStores = create$6(null);
+        const contextStores = create$7(null);
         let initializationPromise = new Promise((resolve) => {
             const finish = () => {
                 resolve();
@@ -45465,7 +45465,7 @@
                 try {
                     const entries = await durableStore.getEntries(adapterContextKeysFromDifferentInstance, AdapterContextSegment);
                     if (entries !== undefined) {
-                        const entryKeys = keys$7(entries);
+                        const entryKeys = keys$8(entries);
                         for (let i = 0, len = entryKeys.length; i < len; i++) {
                             const entryKey = entryKeys[i];
                             const entry = entries[entryKey];
@@ -45500,7 +45500,7 @@
                 if (filteredKeys.length > 0) {
                     const entries = await durableStore.getMetadata(filteredKeys, DefaultDurableSegment);
                     if (entries !== undefined) {
-                        const entryKeys = keys$7(entries);
+                        const entryKeys = keys$8(entries);
                         for (let i = 0, len = entryKeys.length; i < len; i++) {
                             const entryKey = entryKeys[i];
                             const { metadata } = entries[entryKey];
@@ -45872,7 +45872,7 @@
             validateNotDisposed();
             const entryKeys = keys$1.map(serializeStructuredKey);
             const entries = await durableStore.getEntries(entryKeys, DefaultDurableSegment);
-            if (entries === undefined || keys$7(entries).length === 0) {
+            if (entries === undefined || keys$8(entries).length === 0) {
                 return environment.notifyStoreUpdateAvailable(keys$1);
             }
             const now = Date.now();
@@ -45924,7 +45924,7 @@
             type: 'stale-while-revalidate',
             staleDurationSeconds: Number.MAX_SAFE_INTEGER,
         });
-        return create$6(environment, {
+        return create$7(environment, {
             publishStoreMetadata: { value: publishStoreMetadata },
             storeIngest: { value: storeIngest },
             storeIngestError: { value: storeIngestError },
@@ -45960,14 +45960,10 @@
      * For full license text, see the LICENSE.txt file
      */
 
-
-    function isStoreKeyRecordId(key) {
-        return key.indexOf(RECORD_ID_PREFIX$1) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) === -1;
-    }
     function isStoreKeyRecordField(key) {
         return key.indexOf(RECORD_ID_PREFIX$1) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) > -1;
     }
-    function buildRecordFieldStoreKey(recordKey, fieldName) {
+    function buildRecordFieldStoreKey$1(recordKey, fieldName) {
         return `${recordKey}${RECORD_FIELDS_KEY_JUNCTION$1}${fieldName}`;
     }
     function objectsDeepEqual(lhs, rhs) {
@@ -45994,15 +45990,6 @@
         return true;
     }
 
-    function isStoreRecordError(storeRecord) {
-        return storeRecord.__type === 'error';
-    }
-    function isEntryDurableRecordRepresentation(entry, key) {
-        // Either a DurableRecordRepresentation or StoreRecordError can live at a record key
-        return ((isStoreKeyRecordId(key) || isStoreKeyRecordViewEntity$1(key)) &&
-            entry.data.__type === undefined);
-    }
-
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
      * All rights reserved.
@@ -46388,7 +46375,7 @@
     function errors(result) {
         return result.error;
     }
-    function values$4(result) {
+    function values$5(result) {
         return result.value;
     }
     function flattenResults(results) {
@@ -46396,7 +46383,7 @@
         if (fails.length > 0) {
             return failure(fails);
         }
-        return success(results.filter(isSuccess).map(values$4));
+        return success(results.filter(isSuccess).map(values$5));
     }
 
     function getFieldInfo(apiName, fieldName, infoMap) {
@@ -47213,7 +47200,7 @@
     }
 
     const { isArray: isArray$4 } = Array;
-    const { keys: keys$6 } = Object;
+    const { keys: keys$7 } = Object;
 
     function isListValueNode(node) {
         return node.kind === 'ListValue';
@@ -47281,7 +47268,7 @@
         if (failures.length > 0) {
             return failure(failures);
         }
-        const containers = results.filter(isSuccess).map(values$4);
+        const containers = results.filter(isSuccess).map(values$5);
         const predicates = [];
         containers.forEach((c) => {
             if (c.predicate !== undefined) {
@@ -47573,7 +47560,7 @@
         if (fails.length > 0) {
             return failure(fails);
         }
-        const vals = results.filter(isSuccess).reduce(flatMap$1(values$4), []);
+        const vals = results.filter(isSuccess).reduce(flatMap$1(values$5), []);
         return success(vals);
     }
     function isFilterFunction(name) {
@@ -47583,7 +47570,7 @@
         const results = Object.entries(operatorNode.fields)
             .filter(([key, _]) => isFilterFunction(key) === false)
             .map(([key, value]) => operatorWithValue(key, value, dataType));
-        const _values = results.filter(isSuccess).map(values$4);
+        const _values = results.filter(isSuccess).map(values$5);
         const fails = results.filter(isFailure).reduce(flatMap$1(errors), []);
         if (fails.length > 0) {
             return failure(fails);
@@ -48504,7 +48491,7 @@
     }
     function recordFields(luvioSelections, names, parentApiName, parentAlias, input, joins) {
         const results = luvioSelections.map((selection) => selectionToQueryField(selection, names, parentApiName, parentAlias, input, joins));
-        const fields = results.filter(isSuccess).reduce(flatMap$1(values$4), []);
+        const fields = results.filter(isSuccess).reduce(flatMap$1(values$5), []);
         const fails = results.filter(isFailure).reduce(flatMap$1(errors), []);
         if (fails.length > 0) {
             return failure(fails);
@@ -48752,7 +48739,7 @@
     }
     function rootQuery(recordNodes, input) {
         const results = recordNodes.map((record) => rootRecordQuery(record, input));
-        const connections = results.filter(isSuccess).map(values$4);
+        const connections = results.filter(isSuccess).map(values$5);
         const fails = results.filter(isFailure).reduce(flatMap$1(errors), []);
         if (fails.length > 0) {
             return failure(fails);
@@ -48848,7 +48835,7 @@
         switch (valueNode.kind) {
             case Kind$1.OBJECT: {
                 // For example, `{ Id: { eq: $draftId } }` is a `ObjectValueNode`, which has field keys 'Id'
-                const resultQuery = keys$6(valueNode.fields)
+                const resultQuery = keys$7(valueNode.fields)
                     .map((key) => generateVariableSubQuery(valueNode.fields[key], key, type, variables))
                     .filter((subquery) => subquery.length > 0)
                     .join(',');
@@ -48924,7 +48911,7 @@
     }
     function swapValueNodeWithVariableNodes(original, swapped) {
         if (original.kind === Kind$1.OBJECT) {
-            for (const key of keys$6(original.fields)) {
+            for (const key of keys$7(original.fields)) {
                 if (isObjectValueNode$1(swapped) && swapped.fields[key]) {
                     if (is(original.fields[key], 'Variable')) {
                         original.fields[key] = swapped.fields[key];
@@ -49533,7 +49520,7 @@
         return new DraftErrorFetchResponse(HttpStatusCode$1.BadRequest, error);
     }
 
-    const { keys: keys$5, create: create$5, assign: assign$5, values: values$3 } = Object;
+    const { keys: keys$6, create: create$6, assign: assign$6, values: values$4 } = Object;
     const { stringify: stringify$5, parse: parse$5 } = JSON;
     const { isArray: isArray$3$1 } = Array;
 
@@ -49643,13 +49630,13 @@
                 }
                 softEvict(key);
             };
-            return create$5(luvio, {
+            return create$6(luvio, {
                 dispatchResourceRequest: { value: dispatchResourceRequest },
                 publishStoreMetadata: { value: publishStoreMetadata },
                 storeEvict: { value: storeEvict },
             });
         }
-        return create$5(luvio, {
+        return create$6(luvio, {
             dispatchResourceRequest: { value: dispatchResourceRequest },
             publishStoreMetadata: { value: publishStoreMetadata },
         });
@@ -49683,7 +49670,7 @@
         if (entries === undefined) {
             return mappings;
         }
-        const keys$1 = keys$5(entries);
+        const keys$1 = keys$6(entries);
         for (const key of keys$1) {
             const entry = entries[key].data;
             if (isLegacyDraftIdMapping(key)) {
@@ -49701,7 +49688,7 @@
     async function clearDraftIdSegment(durableStore) {
         const entries = await durableStore.getAllEntries(DRAFT_ID_MAPPINGS_SEGMENT);
         if (entries) {
-            const keys$1 = keys$5(entries);
+            const keys$1 = keys$6(entries);
             if (keys$1.length > 0) {
                 await durableStore.evictEntries(keys$1, DRAFT_ID_MAPPINGS_SEGMENT);
             }
@@ -49960,7 +49947,7 @@
                     const queueOperations = handler.getQueueOperationsForCompletingDrafts(queue, action);
                     // write the queue operations to the store prior to ingesting the result
                     await this.draftStore.completeAction(queueOperations);
-                    await handler.handleActionCompleted(action, queueOperations, values$3(this.handlers));
+                    await handler.handleActionCompleted(action, queueOperations, values$4(this.handlers));
                     this.retryIntervalMilliseconds = 0;
                     this.uploadingActionId = undefined;
                     await this.notifyChangedListeners({
@@ -50112,7 +50099,7 @@
             return this.replaceOrMergeActions(targetActionId, sourceActionId, true);
         }
         async setMetadata(actionId, metadata) {
-            const keys$1 = keys$5(metadata);
+            const keys$1 = keys$6(metadata);
             const compatibleKeys = keys$1.filter((key) => {
                 const value = metadata[key];
                 return typeof key === 'string' && typeof value === 'string';
@@ -50267,7 +50254,7 @@
             const waitForOngoingSync = this.syncPromise || Promise.resolve();
             return waitForOngoingSync.then(() => {
                 const { draftStore } = this;
-                const keys$1 = keys$5(draftStore);
+                const keys$1 = keys$6(draftStore);
                 const actionArray = [];
                 for (let i = 0, len = keys$1.length; i < len; i++) {
                     const key = keys$1[i];
@@ -50291,7 +50278,7 @@
         deleteByTag(tag) {
             const deleteAction = () => {
                 const { draftStore } = this;
-                const keys$1 = keys$5(draftStore);
+                const keys$1 = keys$6(draftStore);
                 const durableKeys = [];
                 for (let i = 0, len = keys$1.length; i < len; i++) {
                     const key = keys$1[i];
@@ -50381,7 +50368,7 @@
                         return this.runQueuedOperations();
                     }
                     const { draftStore } = this;
-                    const keys$1 = keys$5(durableEntries);
+                    const keys$1 = keys$6(durableEntries);
                     for (let i = 0, len = keys$1.length; i < len; i++) {
                         const entry = durableEntries[keys$1[i]];
                         const action = entry.data;
@@ -51255,7 +51242,7 @@
             decrementRefCount(key);
         };
         // note the makeEnvironmentUiApiRecordDraftAware will eventually go away once the adapters become draft aware
-        return create$5(env, {
+        return create$6(env, {
             storePublish: { value: storePublish },
             handleSuccessResponse: { value: handleSuccessResponse },
             softEvict: { value: softEvict },
@@ -51269,7 +51256,7 @@
      */
 
 
-    const { keys: keys$4, values: values$2, create: create$4, assign: assign$4, freeze: freeze$3, entries: entries$4 } = Object;
+    const { keys: keys$5, values: values$3, create: create$5, assign: assign$5, freeze: freeze$1$1, entries: entries$5 } = Object;
     const { stringify: stringify$4, parse: parse$4 } = JSON;
     const { shift } = Array.prototype;
     const { isArray: isArray$2$1, from: from$2 } = Array;
@@ -51336,7 +51323,7 @@
      */
     function filterOutReferenceFieldsAndLinks(record) {
         const filteredFields = {};
-        const fieldNames = keys$4(record.fields);
+        const fieldNames = keys$5(record.fields);
         for (const fieldName of fieldNames) {
             const field = record.fields[fieldName];
             if (isFieldLink(field) === false) {
@@ -51437,7 +51424,7 @@
             const resolvedRequest = resolveResourceRequestIds(luvio, resourceRequest, canonicalKey);
             return env.dispatchResourceRequest(resolvedRequest, context, eventObservers);
         };
-        return create$4(env, {
+        return create$5(env, {
             dispatchResourceRequest: { value: dispatchResourceRequest },
         });
     }
@@ -51615,7 +51602,7 @@
                 return applyDraftsToBatchResponse(resourceRequest, response, removedDraftIds);
             }));
         };
-        return create$4(env, {
+        return create$5(env, {
             dispatchResourceRequest: { value: dispatchResourceRequest },
         });
     }
@@ -51625,7 +51612,7 @@
         const adapterSpecificEnvironments = synthesizers.reduce((environment, synthesizer) => {
             return synthesizer(luvio, environment, options);
         }, env);
-        return create$4(adapterSpecificEnvironments, {});
+        return create$5(adapterSpecificEnvironments, {});
     }
 
     function clone(obj) {
@@ -51719,7 +51706,7 @@
                 changedNameFields[fieldName] = fieldValue;
             }
         }
-        if (keys$4(changedNameFields).length > 0) {
+        if (keys$5(changedNameFields).length > 0) {
             const newNameValue = filteredNameFields
                 .map((key) => {
                 if (changedNameFields[key] !== undefined) {
@@ -51802,7 +51789,7 @@
         const injectedCompoundNameField = compoundNameFieldFromDraftUpdates(record, draftOperationFields, apiName, objectInfos);
         // inject the compound Name field into the DraftOperation so on broadcast it doesnt try to
         // synthesize the Name field a second time when the durable store change notifier is triggered
-        if (keys$4(injectedCompoundNameField).length > 0 && draftActionType === 'update') {
+        if (keys$5(injectedCompoundNameField).length > 0 && draftActionType === 'update') {
             draftOperation.fields['Name'] = injectedCompoundNameField['Name'];
         }
         const fields = { ...draftOperationFields, ...injectedCompoundNameField };
@@ -51813,7 +51800,7 @@
             LastModifiedDate: lastModifiedDate,
         };
         const draftFields = buildRecordFieldValueRepresentationsFromDraftFields(luvio, apiName, internalFields, objectInfos, referencedRecords, formatDisplayValue);
-        const fieldNames = keys$4(draftFields);
+        const fieldNames = keys$5(draftFields);
         for (let i = 0, len = fieldNames.length; i < len; i++) {
             const fieldName = fieldNames[i];
             // don't apply server values to draft created records
@@ -51874,7 +51861,7 @@
             return undefined;
         }
         const updatedFields = {};
-        const fieldNames = keys$4(fields);
+        const fieldNames = keys$5(fields);
         for (let i = 0, len = fieldNames.length; i < len; i++) {
             const fieldName = fieldNames[i];
             const field = fields[fieldName];
@@ -51921,7 +51908,7 @@
      * @param fields List of draft record fields
      */
     function buildRecordFieldValueRepresentationsFromDraftFields(luvio, apiName, fields, objectInfos, referencedRecords, formatDisplayValue) {
-        const fieldNames = keys$4(fields);
+        const fieldNames = keys$5(fields);
         const recordFields = {};
         const objectInfo = objectInfos.get(apiName);
         for (let i = 0, len = fieldNames.length; i < len; i++) {
@@ -51989,7 +51976,7 @@
         draftFields[DEFAULT_FIELD_LAST_MODIFIED_DATE] = { value: timestampString, displayValue: null };
         draftFields[DEFAULT_FIELD_OWNER_ID] = { value: userId, displayValue: null };
         draftFields[DEFAULT_FIELD_ID] = { value: recordId, displayValue: null };
-        const allObjectFields = keys$4(objectInfo.fields);
+        const allObjectFields = keys$5(objectInfo.fields);
         allObjectFields.forEach((fieldName) => {
             if (draftFields[fieldName] === undefined) {
                 draftFields[fieldName] = { value: null, displayValue: null };
@@ -52130,7 +52117,7 @@
             this.isDraftId = isDraftId;
             this.recordService = recordService;
             this.handlerId = LDS_ACTION_HANDLER_ID;
-            this.collectedFields = create$4(null);
+            this.collectedFields = create$5(null);
             recordService.registerRecordHandler(this);
         }
         async buildPendingAction(request, queue) {
@@ -52192,7 +52179,7 @@
                     throw Error(`Could not generate draft. Object info is missing`);
                 }
                 const appendedFields = this.getBackdatingFields(objectInfo, resolvedRequest.method, pendingAction);
-                if (keys$4(appendedFields).length > 0) {
+                if (keys$5(appendedFields).length > 0) {
                     pendingAction.data.body = {
                         ...pendingAction.data.body,
                         fields: {
@@ -52206,7 +52193,7 @@
         }
         getBackdatingFields(objectInfo, requestMethod, pendingAction) {
             const fields = {};
-            const actionFieldNames = keys$4(pendingAction.data.body.fields);
+            const actionFieldNames = keys$5(pendingAction.data.body.fields);
             if (requestMethod === 'post') {
                 // `CreateRecord` with `CreatedDate` field
                 if (isBackdatingFieldEditable(objectInfo, DEFAULT_FIELD_CREATED_DATE$1, 'createable', actionFieldNames)) {
@@ -52252,7 +52239,7 @@
                     return;
                 }
                 const objectInfo = objectInfoMap[apiName];
-                const optionalFields = values$2(objectInfo.fields).map((field) => `${apiName}.${field.apiName}`);
+                const optionalFields = values$3(objectInfo.fields).map((field) => `${apiName}.${field.apiName}`);
                 await getAdapterData(this.getRecordAdapter, {
                     recordId: referenceFieldInfo.id,
                     optionalFields,
@@ -52271,7 +52258,7 @@
             const referenceToInfos = fieldInfo.referenceToInfos;
             const apiNames = referenceToInfos.map((referenceToInfo) => referenceToInfo.apiName);
             const objectInfoMap = await this.objectInfoService.getObjectInfos(apiNames);
-            for (const objectInfo of values$2(objectInfoMap)) {
+            for (const objectInfo of values$3(objectInfoMap)) {
                 const { apiName, keyPrefix } = objectInfo;
                 if (keyPrefix !== null && id.startsWith(keyPrefix)) {
                     return apiName;
@@ -52399,17 +52386,17 @@
             // otherwise we're a record
             if (draftMetadata === undefined) {
                 // no drafts applied to this record, publish and be done
-                this.collectedFields = create$4(null);
+                this.collectedFields = create$5(null);
                 return publishData(key, data);
             }
             // create a denormalized record with the collected fields
-            const recordFieldNames = keys$4(data.fields);
+            const recordFieldNames = keys$5(data.fields);
             const partialRecord = {
                 ...data,
                 fields: {},
             };
             for (const fieldName of recordFieldNames) {
-                const collectedField = this.collectedFields[buildRecordFieldStoreKey(key, fieldName)];
+                const collectedField = this.collectedFields[buildRecordFieldStoreKey$1(key, fieldName)];
                 if (collectedField !== undefined) {
                     partialRecord.fields[fieldName] =
                         collectedField;
@@ -52425,15 +52412,15 @@
                 lastModifiedDate: recordWithDrafts.lastModifiedDate,
                 lastModifiedById: recordWithDrafts.lastModifiedById,
             };
-            for (const fieldName of keys$4(recordWithSpanningRefLinks.fields)) {
-                const fieldKey = buildRecordFieldStoreKey(key, fieldName);
+            for (const fieldName of keys$5(recordWithSpanningRefLinks.fields)) {
+                const fieldKey = buildRecordFieldStoreKey$1(key, fieldName);
                 normalizedRecord.fields[fieldName] = { __ref: fieldKey };
                 publishData(fieldKey, recordWithSpanningRefLinks.fields[fieldName]);
             }
             // publish the normalized record
             publishData(key, normalizedRecord);
             // we've published the record, now clear the collected fields
-            this.collectedFields = create$4(null);
+            this.collectedFields = create$5(null);
         }
         updateMetadata(existingMetadata, incomingMetadata) {
             // ensure the the api name cannot be overwritten in the incoming metadata
@@ -52470,7 +52457,7 @@
             let resolvedUrlParams = request.urlParams;
             if (request.method === 'post' || request.method === 'patch') {
                 const bodyFields = resolvedBody.fields;
-                const fieldNames = keys$4(bodyFields);
+                const fieldNames = keys$5(bodyFields);
                 for (let i = 0, len = fieldNames.length; i < len; i++) {
                     const fieldName = fieldNames[i];
                     const fieldValue = bodyFields[fieldName];
@@ -52564,366 +52551,6 @@
             !draftActionFieldNames.includes(backdatingFieldName));
     }
 
-    function createLink$2(key) {
-        return { __ref: key };
-    }
-    /**
-     * Records are stored in the durable store with scalar fields denormalized. This function takes that denoramlized
-     * durable store record representation and normalizes it back out into the format the the luvio store expects it
-     * @param key Record store key
-     * @param entry Durable entry containing a denormalized record representation
-     * @returns a set of entries containing the normalized record and its normalized fields
-     */
-    function normalizeRecordFields(key, entry) {
-        const { data: record } = entry;
-        const { fields, links } = record;
-        const missingFieldLinks = keys$4(links);
-        const fieldNames = keys$4(fields);
-        const normalizedFields = {};
-        const returnEntries = {};
-        // restore fields
-        for (let i = 0, len = fieldNames.length; i < len; i++) {
-            const fieldName = fieldNames[i];
-            const field = fields[fieldName];
-            const fieldKey = buildRecordFieldStoreKey(key, fieldName);
-            returnEntries[fieldKey] = { data: field };
-            normalizedFields[fieldName] = createLink$2(fieldKey);
-        }
-        // restore missing fields
-        for (let i = 0, len = missingFieldLinks.length; i < len; i++) {
-            const fieldName = missingFieldLinks[i];
-            const link = links[fieldName];
-            if (link.isMissing === true) {
-                normalizedFields[fieldName] = { ...link, __ref: undefined };
-            }
-        }
-        returnEntries[key] = {
-            data: assign$4(record, { fields: normalizedFields }),
-            metadata: entry.metadata,
-        };
-        return returnEntries;
-    }
-    /**
-     * Transforms a record for storage in the durable store. The transformation involves denormalizing
-     * scalar fields and persisting link metadata to transform back into a normalized representation
-     *
-     * If the record contains pending fields this will return undefined as pending records do not get persisted
-     * to the durable store. There should be a refresh operation outbound that will bring in the updated record.
-     *
-     * @param normalizedRecord Record containing normalized field links
-     * @param recordStore a store containing referenced record fields
-     */
-    function buildDurableRecordRepresentation(normalizedRecord, records, pendingEntries, store) {
-        const fields = normalizedRecord.fields;
-        const filteredFields = {};
-        const links = {};
-        const fieldNames = keys$4(fields);
-        for (let i = 0, len = fieldNames.length; i < len; i++) {
-            const fieldName = fieldNames[i];
-            const field = fields[fieldName];
-            // pending fields get filtered out of the durable store
-            const { pending } = field;
-            if (pending === true) {
-                // do not write records with pending fields to the durable store
-                // there should be a refresh operation outbound that will bring in the updated record
-                return undefined;
-            }
-            const { __ref } = field;
-            if (__ref !== undefined) {
-                let ref = records[__ref];
-                if (pendingEntries !== undefined) {
-                    // If the ref was part of the pending write that takes precedence
-                    const pendingEntry = pendingEntries[__ref];
-                    if (pendingEntry !== undefined) {
-                        ref = pendingEntry.data;
-                    }
-                }
-                // if field reference exists then add it to our filteredFields
-                if (ref !== undefined) {
-                    filteredFields[fieldName] = ref;
-                }
-                else {
-                    // if we have a store to read, try to find the field there too
-                    // The durable ingest staging store may pass through to L1, and
-                    // not all fields are necessarily published every time, so it is
-                    // important to check L1 and not just the fields being published,
-                    // otherwise we risk truncating the fields on the record.
-                    if (store) {
-                        ref = store.readEntry(__ref);
-                        if (ref !== undefined) {
-                            filteredFields[fieldName] = ref;
-                        }
-                    }
-                }
-            }
-            // we want to preserve fields that are missing nodes
-            if (field.isMissing === true) {
-                links[fieldName] = field;
-            }
-        }
-        return {
-            ...normalizedRecord,
-            fields: filteredFields,
-            links,
-        };
-    }
-    function getDenormalizedKey(originalKey, recordId, luvio) {
-        // this will likely need to be handled when moving to structured keys
-        // note record view entities dont have an associated keybuilder. They get ingested as records to a different key format
-        // see the override for how they are handled packages/lds-adapters-uiapi/src/raml-artifacts/types/RecordRepresentation/keyBuilderFromType.ts
-        if (originalKey.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX$1)) {
-            return RECORD_VIEW_ENTITY_ID_PREFIX$1 + recordId;
-        }
-        return keyBuilder$26(luvio, { recordId });
-    }
-    function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecords, getStoreMetadata, getStore, sqlStore) {
-        const getEntries = function (entries, segment) {
-            // this HOF only inspects records in the default segment
-            if (segment !== DefaultDurableSegment) {
-                return durableStore.getEntries(entries, segment);
-            }
-            const { length: entriesLength } = entries;
-            if (entriesLength === 0) {
-                return Promise.resolve({});
-            }
-            // filter out record field keys
-            const filteredEntryIds = [];
-            // map of records to avoid requesting duplicate record keys when requesting both records and fields
-            const recordEntries = {};
-            const recordViewEntries = {};
-            for (let i = 0, len = entriesLength; i < len; i++) {
-                const id = entries[i];
-                const recordId = extractRecordIdFromStoreKey$1(id);
-                if (recordId !== undefined) {
-                    if (id.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX$1)) {
-                        if (recordViewEntries[recordId] === undefined) {
-                            const key = getDenormalizedKey(id, recordId, luvio);
-                            recordViewEntries[recordId] = true;
-                            filteredEntryIds.push(key);
-                        }
-                    }
-                    else {
-                        if (recordEntries[recordId] === undefined) {
-                            const key = getDenormalizedKey(id, recordId, luvio);
-                            recordEntries[recordId] = true;
-                            filteredEntryIds.push(key);
-                        }
-                    }
-                }
-                else {
-                    filteredEntryIds.push(id);
-                }
-            }
-            // call base getEntries
-            return durableStore.getEntries(filteredEntryIds, segment).then((durableEntries) => {
-                if (durableEntries === undefined) {
-                    return undefined;
-                }
-                const returnEntries = create$4(null);
-                const keys$1 = keys$4(durableEntries);
-                for (let i = 0, len = keys$1.length; i < len; i++) {
-                    const key = keys$1[i];
-                    const value = durableEntries[key];
-                    if (value === undefined) {
-                        continue;
-                    }
-                    if (isEntryDurableRecordRepresentation(value, key)) {
-                        assign$4(returnEntries, normalizeRecordFields(key, value));
-                    }
-                    else {
-                        returnEntries[key] = value;
-                    }
-                }
-                return returnEntries;
-            });
-        };
-        const denormalizeEntries = function (entries) {
-            let hasEntries = false;
-            let hasMetadata = false;
-            const putEntries = create$4(null);
-            const putMetadata = create$4(null);
-            const keys$1 = keys$4(entries);
-            const putRecords = {};
-            const putRecordViews = {};
-            const storeRecords = getStoreRecords !== undefined ? getStoreRecords() : {};
-            const storeMetadata = getStoreMetadata !== undefined ? getStoreMetadata() : {};
-            const store = getStore();
-            for (let i = 0, len = keys$1.length; i < len; i++) {
-                const key = keys$1[i];
-                let value = entries[key];
-                const recordId = extractRecordIdFromStoreKey$1(key);
-                // do not put normalized field values
-                if (recordId !== undefined) {
-                    const isRecordView = key.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX$1);
-                    if (isRecordView) {
-                        if (putRecordViews[recordId] === true) {
-                            continue;
-                        }
-                    }
-                    else {
-                        if (putRecords[recordId] === true) {
-                            continue;
-                        }
-                    }
-                    const recordKey = getDenormalizedKey(key, recordId, luvio);
-                    const recordEntries = entries;
-                    const entry = recordEntries[recordKey];
-                    let record = entry && entry.data;
-                    if (record === undefined) {
-                        record = storeRecords[recordKey];
-                        if (record === undefined) {
-                            // fields are being published without a record for them existing,
-                            // fields cannot exist standalone in the durable store
-                            continue;
-                        }
-                    }
-                    if (isRecordView) {
-                        putRecordViews[recordId] = true;
-                    }
-                    else {
-                        putRecords[recordId] = true;
-                    }
-                    if (isStoreRecordError(record)) {
-                        hasEntries = true;
-                        putEntries[recordKey] = value;
-                        continue;
-                    }
-                    let metadata = entry && entry.metadata;
-                    if (metadata === undefined) {
-                        metadata = {
-                            ...storeMetadata[recordKey],
-                            metadataVersion: DURABLE_METADATA_VERSION,
-                        };
-                    }
-                    const denormalizedRecord = buildDurableRecordRepresentation(record, storeRecords, recordEntries, store);
-                    if (denormalizedRecord !== undefined) {
-                        hasEntries = true;
-                        putEntries[recordKey] = {
-                            data: denormalizedRecord,
-                            metadata,
-                        };
-                        // if undefined then it is pending
-                        // we should still update metadata on pending records
-                    }
-                    else {
-                        hasMetadata = true;
-                        metadata.expirationTimestamp = metadata.ingestionTimestamp;
-                        putMetadata[recordKey] = {
-                            metadata,
-                        };
-                    }
-                }
-                else {
-                    hasEntries = true;
-                    putEntries[key] = value;
-                }
-            }
-            return { putEntries, putMetadata, hasEntries, hasMetadata };
-        };
-        const setEntries = function (entries, segment) {
-            if (segment !== DefaultDurableSegment) {
-                return durableStore.setEntries(entries, segment);
-            }
-            const { putEntries, putMetadata, hasEntries, hasMetadata } = denormalizeEntries(entries);
-            const promises = [
-                hasEntries ? durableStore.setEntries(putEntries, segment) : undefined,
-            ];
-            if (sqlStore !== undefined && sqlStore.isBatchUpdateSupported()) {
-                promises.push(hasMetadata && sqlStore !== undefined
-                    ? durableStore.setMetadata(putMetadata, segment)
-                    : undefined);
-            }
-            return Promise.all(promises).then(() => { });
-        };
-        const batchOperations = function (operations) {
-            const operationsWithDenormedRecords = [];
-            for (let i = 0, len = operations.length; i < len; i++) {
-                const operation = operations[i];
-                if (operation.type === 'setMetadata') {
-                    // if setMetadata also contains entry data then it needs to be denormalized.
-                    const keys$1 = keys$4(operation.entries);
-                    if (keys$1.length > 0) {
-                        const firstKey = keys$1[0];
-                        // casted to any to check if data exists
-                        const firstEntry = operation.entries[firstKey];
-                        // it is not possible for setMetadata to contain entries with both data and no data in the same operation.
-                        // this is determined by the plugin supporting update batch calls before it gets to this HOF.
-                        // so we only need to check one entry to confirm this for performance
-                        if (firstEntry.data !== undefined) {
-                            const { putEntries, putMetadata, hasMetadata } = denormalizeEntries(operation.entries);
-                            operationsWithDenormedRecords.push({
-                                ...operation,
-                                entries: putEntries,
-                            });
-                            if (hasMetadata &&
-                                sqlStore !== undefined &&
-                                sqlStore.isBatchUpdateSupported() === true) {
-                                operationsWithDenormedRecords.push({
-                                    ...operation,
-                                    entries: putMetadata,
-                                    type: 'setMetadata',
-                                });
-                            }
-                        }
-                        else {
-                            operationsWithDenormedRecords.push(operation);
-                        }
-                    }
-                    continue;
-                }
-                if (operation.segment !== DefaultDurableSegment || operation.type === 'evictEntries') {
-                    operationsWithDenormedRecords.push(operation);
-                    continue;
-                }
-                const { putEntries, putMetadata, hasMetadata } = denormalizeEntries(operation.entries);
-                operationsWithDenormedRecords.push({
-                    ...operation,
-                    entries: putEntries,
-                });
-                if (hasMetadata &&
-                    sqlStore !== undefined &&
-                    sqlStore.isBatchUpdateSupported() === true) {
-                    operationsWithDenormedRecords.push({
-                        ...operation,
-                        entries: putMetadata,
-                        type: 'setMetadata',
-                    });
-                }
-            }
-            return durableStore.batchOperations(operationsWithDenormedRecords);
-        };
-        /**
-         * Retrieves a denormalized record from the store
-         * NOTE: do no use this if you don't know what you're doing, this can still contain normalized record references
-         * @param recordKey record key
-         * @param durableStore the durable store
-         * @returns a DraftRecordRepresentation containing the requested fields
-         */
-        const getDenormalizedRecord = function (recordKey) {
-            return durableStore.getEntries([recordKey], DefaultDurableSegment).then((entries) => {
-                if (entries === undefined) {
-                    return undefined;
-                }
-                const denormalizedEntry = entries[recordKey];
-                if (denormalizedEntry === undefined) {
-                    return undefined;
-                }
-                // don't include link information
-                const denormalizedRecord = denormalizedEntry.data;
-                if (isStoreRecordError(denormalizedRecord)) {
-                    return undefined;
-                }
-                return denormalizedRecord;
-            });
-        };
-        return create$4(durableStore, {
-            getEntries: { value: getEntries, writable: true },
-            setEntries: { value: setEntries, writable: true },
-            batchOperations: { value: batchOperations, writable: true },
-            getDenormalizedRecord: { value: getDenormalizedRecord, writable: true },
-        });
-    }
-
     /**
      * This function takes an unknown error and normalizes it to an Error object
      */
@@ -52962,7 +52589,7 @@
             }
             return createOkResponse(data);
         };
-        return create$4(env, {
+        return create$5(env, {
             dispatchResourceRequest: { value: dispatchResourceRequest },
         });
     }
@@ -53029,7 +52656,7 @@
                     };
                 }
                 objectInfoMap.set(apiName, objectInfo);
-                const fields = keys$4(operation.fields);
+                const fields = keys$5(operation.fields);
                 const unexpectedFields = [];
                 for (const field of fields) {
                     const fieldInfo = objectInfo.fields[field];
@@ -53353,7 +52980,7 @@
                     ...trimmedDownData.contentVersion,
                     fields: cvFields,
                 };
-                freeze$3(trimmedDownData);
+                freeze$1$1(trimmedDownData);
                 snapshot.data = trimmedDownData;
             }
             eventEmitter({ type: 'create-content-document-and-version-draft-finished' });
@@ -53367,14 +52994,13 @@
     const CONTENT_VERSION_API_NAME = 'ContentVersion';
     const LATEST_PUBLISHED_VERSION_ID_FIELD = 'LatestPublishedVersionId';
     class ContentDocumentCompositeRepresentationActionHandler extends AbstractResourceRequestActionHandler {
-        constructor(getLuvio, draftRecordService, draftQueue, networkAdapter, isDraftId, durableStore, binaryStore) {
+        constructor(getLuvio, draftRecordService, draftQueue, networkAdapter, isDraftId, binaryStore) {
             super(draftQueue, networkAdapter, getLuvio);
             this.getLuvio = getLuvio;
             this.draftRecordService = draftRecordService;
             this.draftQueue = draftQueue;
             this.networkAdapter = networkAdapter;
             this.isDraftId = isDraftId;
-            this.durableStore = durableStore;
             this.binaryStore = binaryStore;
             this.binaryStoreUrlsToUpdate = new Map();
             this.handlerId = HANDLER_ID;
@@ -53786,6 +53412,389 @@
         };
     }
 
+    /**
+     * Copyright (c) 2022, Salesforce, Inc.,
+     * All rights reserved.
+     * For full license text, see the LICENSE.txt file
+     */
+
+
+    const { keys: keys$4, values: values$2, create: create$4, assign: assign$4, freeze: freeze$3, entries: entries$4 } = Object;
+
+    function buildRecordFieldStoreKey(recordKey, fieldName) {
+        return `${recordKey}${RECORD_FIELDS_KEY_JUNCTION$1}${fieldName}`;
+    }
+    function isStoreKeyRecordId(key) {
+        return key.indexOf(RECORD_ID_PREFIX$1) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) === -1;
+    }
+    function createLink$2(key) {
+        return { __ref: key };
+    }
+    function isStoreRecordError(storeRecord) {
+        return storeRecord.__type === 'error';
+    }
+    function isEntryDurableRecordRepresentation(entry, key) {
+        // Either a DurableRecordRepresentation or StoreRecordError can live at a record key
+        return ((isStoreKeyRecordId(key) || isStoreKeyRecordViewEntity$1(key)) &&
+            entry.data.__type === undefined);
+    }
+    /**
+     * Records are stored in the durable store with scalar fields denormalized. This function takes that denoramlized
+     * durable store record representation and normalizes it back out into the format the the luvio store expects it
+     * @param key Record store key
+     * @param entry Durable entry containing a denormalized record representation
+     * @returns a set of entries containing the normalized record and its normalized fields
+     */
+    function normalizeRecordFields(key, entry) {
+        const { data: record } = entry;
+        const { fields, links } = record;
+        const missingFieldLinks = keys$4(links);
+        const fieldNames = keys$4(fields);
+        const normalizedFields = {};
+        const returnEntries = {};
+        // restore fields
+        for (let i = 0, len = fieldNames.length; i < len; i++) {
+            const fieldName = fieldNames[i];
+            const field = fields[fieldName];
+            const fieldKey = buildRecordFieldStoreKey(key, fieldName);
+            returnEntries[fieldKey] = { data: field };
+            normalizedFields[fieldName] = createLink$2(fieldKey);
+        }
+        // restore missing fields
+        for (let i = 0, len = missingFieldLinks.length; i < len; i++) {
+            const fieldName = missingFieldLinks[i];
+            const link = links[fieldName];
+            if (link.isMissing === true) {
+                normalizedFields[fieldName] = { ...link, __ref: undefined };
+            }
+        }
+        returnEntries[key] = {
+            data: assign$4(record, { fields: normalizedFields }),
+            metadata: entry.metadata,
+        };
+        return returnEntries;
+    }
+    /**
+     * Transforms a record for storage in the durable store. The transformation involves denormalizing
+     * scalar fields and persisting link metadata to transform back into a normalized representation
+     *
+     * If the record contains pending fields this will return undefined as pending records do not get persisted
+     * to the durable store. There should be a refresh operation outbound that will bring in the updated record.
+     *
+     * @param normalizedRecord Record containing normalized field links
+     * @param recordStore a store containing referenced record fields
+     */
+    function buildDurableRecordRepresentation(normalizedRecord, records, pendingEntries, store) {
+        const fields = normalizedRecord.fields;
+        const filteredFields = {};
+        const links = {};
+        const fieldNames = keys$4(fields);
+        for (let i = 0, len = fieldNames.length; i < len; i++) {
+            const fieldName = fieldNames[i];
+            const field = fields[fieldName];
+            // pending fields get filtered out of the durable store
+            const { pending } = field;
+            if (pending === true) {
+                // do not write records with pending fields to the durable store
+                // there should be a refresh operation outbound that will bring in the updated record
+                return undefined;
+            }
+            const { __ref } = field;
+            if (__ref !== undefined) {
+                let ref = records[__ref];
+                if (pendingEntries !== undefined) {
+                    // If the ref was part of the pending write that takes precedence
+                    const pendingEntry = pendingEntries[__ref];
+                    if (pendingEntry !== undefined) {
+                        ref = pendingEntry.data;
+                    }
+                }
+                // if field reference exists then add it to our filteredFields
+                if (ref !== undefined) {
+                    filteredFields[fieldName] = ref;
+                }
+                else {
+                    // if we have a store to read, try to find the field there too
+                    // The durable ingest staging store may pass through to L1, and
+                    // not all fields are necessarily published every time, so it is
+                    // important to check L1 and not just the fields being published,
+                    // otherwise we risk truncating the fields on the record.
+                    if (store) {
+                        ref = store.readEntry(__ref);
+                        if (ref !== undefined) {
+                            filteredFields[fieldName] = ref;
+                        }
+                    }
+                }
+            }
+            // we want to preserve fields that are missing nodes
+            if (field.isMissing === true) {
+                links[fieldName] = field;
+            }
+        }
+        return {
+            ...normalizedRecord,
+            fields: filteredFields,
+            links,
+        };
+    }
+    function getDenormalizedKey(originalKey, recordId, luvio) {
+        // this will likely need to be handled when moving to structured keys
+        // note record view entities dont have an associated keybuilder. They get ingested as records to a different key format
+        // see the override for how they are handled packages/lds-adapters-uiapi/src/raml-artifacts/types/RecordRepresentation/keyBuilderFromType.ts
+        if (originalKey.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX$1)) {
+            return RECORD_VIEW_ENTITY_ID_PREFIX$1 + recordId;
+        }
+        return keyBuilder$26(luvio, { recordId });
+    }
+    function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecords, getStoreMetadata, getStore, sqlStore) {
+        const getEntries = function (entries, segment) {
+            // this HOF only inspects records in the default segment
+            if (segment !== DefaultDurableSegment) {
+                return durableStore.getEntries(entries, segment);
+            }
+            const { length: entriesLength } = entries;
+            if (entriesLength === 0) {
+                return Promise.resolve({});
+            }
+            // filter out record field keys
+            const filteredEntryIds = [];
+            // map of records to avoid requesting duplicate record keys when requesting both records and fields
+            const recordEntries = {};
+            const recordViewEntries = {};
+            for (let i = 0, len = entriesLength; i < len; i++) {
+                const id = entries[i];
+                const recordId = extractRecordIdFromStoreKey$1(id);
+                if (recordId !== undefined) {
+                    if (id.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX$1)) {
+                        if (recordViewEntries[recordId] === undefined) {
+                            const key = getDenormalizedKey(id, recordId, luvio);
+                            recordViewEntries[recordId] = true;
+                            filteredEntryIds.push(key);
+                        }
+                    }
+                    else {
+                        if (recordEntries[recordId] === undefined) {
+                            const key = getDenormalizedKey(id, recordId, luvio);
+                            recordEntries[recordId] = true;
+                            filteredEntryIds.push(key);
+                        }
+                    }
+                }
+                else {
+                    filteredEntryIds.push(id);
+                }
+            }
+            // call base getEntries
+            return durableStore.getEntries(filteredEntryIds, segment).then((durableEntries) => {
+                if (durableEntries === undefined) {
+                    return undefined;
+                }
+                const returnEntries = create$4(null);
+                const keys$1 = keys$4(durableEntries);
+                for (let i = 0, len = keys$1.length; i < len; i++) {
+                    const key = keys$1[i];
+                    const value = durableEntries[key];
+                    if (value === undefined) {
+                        continue;
+                    }
+                    if (isEntryDurableRecordRepresentation(value, key)) {
+                        assign$4(returnEntries, normalizeRecordFields(key, value));
+                    }
+                    else {
+                        returnEntries[key] = value;
+                    }
+                }
+                return returnEntries;
+            });
+        };
+        const denormalizeEntries = function (entries) {
+            let hasEntries = false;
+            let hasMetadata = false;
+            const putEntries = create$4(null);
+            const putMetadata = create$4(null);
+            const keys$1 = keys$4(entries);
+            const putRecords = {};
+            const putRecordViews = {};
+            const storeRecords = getStoreRecords !== undefined ? getStoreRecords() : {};
+            const storeMetadata = getStoreMetadata !== undefined ? getStoreMetadata() : {};
+            const store = getStore();
+            for (let i = 0, len = keys$1.length; i < len; i++) {
+                const key = keys$1[i];
+                let value = entries[key];
+                const recordId = extractRecordIdFromStoreKey$1(key);
+                // do not put normalized field values
+                if (recordId !== undefined) {
+                    const isRecordView = key.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX$1);
+                    if (isRecordView) {
+                        if (putRecordViews[recordId] === true) {
+                            continue;
+                        }
+                    }
+                    else {
+                        if (putRecords[recordId] === true) {
+                            continue;
+                        }
+                    }
+                    const recordKey = getDenormalizedKey(key, recordId, luvio);
+                    const recordEntries = entries;
+                    const entry = recordEntries[recordKey];
+                    let record = entry && entry.data;
+                    if (record === undefined) {
+                        record = storeRecords[recordKey];
+                        if (record === undefined) {
+                            // fields are being published without a record for them existing,
+                            // fields cannot exist standalone in the durable store
+                            continue;
+                        }
+                    }
+                    if (isRecordView) {
+                        putRecordViews[recordId] = true;
+                    }
+                    else {
+                        putRecords[recordId] = true;
+                    }
+                    if (isStoreRecordError(record)) {
+                        hasEntries = true;
+                        putEntries[recordKey] = value;
+                        continue;
+                    }
+                    let metadata = entry && entry.metadata;
+                    if (metadata === undefined) {
+                        metadata = {
+                            ...storeMetadata[recordKey],
+                            metadataVersion: DURABLE_METADATA_VERSION,
+                        };
+                    }
+                    const denormalizedRecord = buildDurableRecordRepresentation(record, storeRecords, recordEntries, store);
+                    if (denormalizedRecord !== undefined) {
+                        hasEntries = true;
+                        putEntries[recordKey] = {
+                            data: denormalizedRecord,
+                            metadata,
+                        };
+                        // if undefined then it is pending
+                        // we should still update metadata on pending records
+                    }
+                    else {
+                        hasMetadata = true;
+                        metadata.expirationTimestamp = metadata.ingestionTimestamp;
+                        putMetadata[recordKey] = {
+                            metadata,
+                        };
+                    }
+                }
+                else {
+                    hasEntries = true;
+                    putEntries[key] = value;
+                }
+            }
+            return { putEntries, putMetadata, hasEntries, hasMetadata };
+        };
+        const setEntries = function (entries, segment) {
+            if (segment !== DefaultDurableSegment) {
+                return durableStore.setEntries(entries, segment);
+            }
+            const { putEntries, putMetadata, hasEntries, hasMetadata } = denormalizeEntries(entries);
+            const promises = [
+                hasEntries ? durableStore.setEntries(putEntries, segment) : undefined,
+            ];
+            if (sqlStore !== undefined && sqlStore.isBatchUpdateSupported()) {
+                promises.push(hasMetadata && sqlStore !== undefined
+                    ? durableStore.setMetadata(putMetadata, segment)
+                    : undefined);
+            }
+            return Promise.all(promises).then(() => { });
+        };
+        const batchOperations = function (operations) {
+            const operationsWithDenormedRecords = [];
+            for (let i = 0, len = operations.length; i < len; i++) {
+                const operation = operations[i];
+                if (operation.type === 'setMetadata') {
+                    // if setMetadata also contains entry data then it needs to be denormalized.
+                    const keys$1 = keys$4(operation.entries);
+                    if (keys$1.length > 0) {
+                        const firstKey = keys$1[0];
+                        // casted to any to check if data exists
+                        const firstEntry = operation.entries[firstKey];
+                        // it is not possible for setMetadata to contain entries with both data and no data in the same operation.
+                        // this is determined by the plugin supporting update batch calls before it gets to this HOF.
+                        // so we only need to check one entry to confirm this for performance
+                        if (firstEntry.data !== undefined) {
+                            const { putEntries, putMetadata, hasMetadata } = denormalizeEntries(operation.entries);
+                            operationsWithDenormedRecords.push({
+                                ...operation,
+                                entries: putEntries,
+                            });
+                            if (hasMetadata &&
+                                sqlStore !== undefined &&
+                                sqlStore.isBatchUpdateSupported() === true) {
+                                operationsWithDenormedRecords.push({
+                                    ...operation,
+                                    entries: putMetadata,
+                                    type: 'setMetadata',
+                                });
+                            }
+                        }
+                        else {
+                            operationsWithDenormedRecords.push(operation);
+                        }
+                    }
+                    continue;
+                }
+                if (operation.segment !== DefaultDurableSegment || operation.type === 'evictEntries') {
+                    operationsWithDenormedRecords.push(operation);
+                    continue;
+                }
+                const { putEntries, putMetadata, hasMetadata } = denormalizeEntries(operation.entries);
+                operationsWithDenormedRecords.push({
+                    ...operation,
+                    entries: putEntries,
+                });
+                if (hasMetadata &&
+                    sqlStore !== undefined &&
+                    sqlStore.isBatchUpdateSupported() === true) {
+                    operationsWithDenormedRecords.push({
+                        ...operation,
+                        entries: putMetadata,
+                        type: 'setMetadata',
+                    });
+                }
+            }
+            return durableStore.batchOperations(operationsWithDenormedRecords);
+        };
+        /**
+         * Retrieves a denormalized record from the store
+         * NOTE: do no use this if you don't know what you're doing, this can still contain normalized record references
+         * @param recordKey record key
+         * @param durableStore the durable store
+         * @returns a DraftRecordRepresentation containing the requested fields
+         */
+        const getDenormalizedRecord = function (recordKey) {
+            return durableStore.getEntries([recordKey], DefaultDurableSegment).then((entries) => {
+                if (entries === undefined) {
+                    return undefined;
+                }
+                const denormalizedEntry = entries[recordKey];
+                if (denormalizedEntry === undefined) {
+                    return undefined;
+                }
+                // don't include link information
+                const denormalizedRecord = denormalizedEntry.data;
+                if (isStoreRecordError(denormalizedRecord)) {
+                    return undefined;
+                }
+                return denormalizedRecord;
+            });
+        };
+        return create$4(durableStore, {
+            getEntries: { value: getEntries, writable: true },
+            setEntries: { value: setEntries, writable: true },
+            batchOperations: { value: batchOperations, writable: true },
+            getDenormalizedRecord: { value: getDenormalizedRecord, writable: true },
+        });
+    }
+
     function serializeFieldArguments$1(argumentNodes, variables) {
         const mutableArgumentNodes = Object.assign([], argumentNodes);
         return `args__(${mutableArgumentNodes
@@ -60587,7 +60596,7 @@
         };
     }
 
-    const { keys: keys$9, create: create$7, assign: assign$7, entries, values } = Object;
+    const { keys: keys$a, create: create$8, assign: assign$8, entries, values } = Object;
     const { stringify: stringify$7, parse: parse$7 } = JSON;
 
     function selectColumnsFromTableWhereKeyIn(columnNames, table, keyColumnName, whereIn) {
@@ -60654,7 +60663,7 @@
                 },
                 conflictColumns: this.conflictColumnNames,
                 columns: this.columnNames,
-                rows: keys$9(entries).reduce((rows, key) => {
+                rows: keys$a(entries).reduce((rows, key) => {
                     const entry = entries[key];
                     const { data, metadata } = entry;
                     const row = [key, stringify$7(data), metadata ? stringify$7(metadata) : null];
@@ -60673,7 +60682,7 @@
                     type: 'setMetadata',
                 },
                 columns: [COLUMN_NAME_METADATA$1],
-                values: keys$9(entries).reduce((values, key) => {
+                values: keys$a(entries).reduce((values, key) => {
                     const { metadata } = entries[key];
                     const row = [metadata ? stringify$7(metadata) : null];
                     values[key] = row;
@@ -60763,7 +60772,7 @@
                 },
                 conflictColumns: this.conflictColumnNames,
                 columns: this.columnNames,
-                rows: keys$9(entries).reduce((rows, key) => {
+                rows: keys$a(entries).reduce((rows, key) => {
                     const entry = entries[key];
                     const { data, metadata } = entry;
                     const row = [key, stringify$7(data)];
@@ -60789,7 +60798,7 @@
                     type: 'setMetadata',
                 },
                 columns: [COLUMN_NAME_METADATA],
-                values: keys$9(entries).reduce((values, key) => {
+                values: keys$a(entries).reduce((values, key) => {
                     const { metadata } = entries[key];
                     const row = [metadata ? stringify$7(metadata) : null];
                     values[key] = row;
@@ -60798,7 +60807,7 @@
             };
         }
         metadataToUpdateSQLQueries(entries, segment) {
-            return keys$9(entries).reduce((accu, key) => {
+            return keys$a(entries).reduce((accu, key) => {
                 const { metadata } = entries[key];
                 if (metadata !== undefined) {
                     accu.push({
@@ -60869,7 +60878,7 @@
             return this.getTable(segment).getAll(segment);
         }
         setEntries(entries, segment) {
-            if (keys$9(entries).length === 0) {
+            if (keys$a(entries).length === 0) {
                 return Promise.resolve();
             }
             const table = this.getTable(segment);
@@ -60877,7 +60886,7 @@
             return this.batchOperationAsPromise([upsertOperation]);
         }
         setMetadata(entries, segment) {
-            if (keys$9(entries).length === 0) {
+            if (keys$a(entries).length === 0) {
                 return Promise.resolve();
             }
             const table = this.getTable(segment);
@@ -60896,13 +60905,13 @@
         batchOperations(operations) {
             const sqliteOperations = operations.reduce((acc, cur) => {
                 if (cur.type === 'setEntries') {
-                    if (keys$9(cur.entries).length > 0) {
+                    if (keys$a(cur.entries).length > 0) {
                         const table = this.getTable(cur.segment);
                         acc.push(table.entriesToUpsertOperations(cur.entries, cur.segment));
                     }
                 }
                 else if (cur.type === 'setMetadata') {
-                    if (keys$9(cur.entries).length > 0) {
+                    if (keys$a(cur.entries).length > 0) {
                         const table = this.getTable(cur.segment);
                         if (this.supportsBatchUpdates) {
                             acc.push(table.metadataToUpdateOperations(cur.entries, cur.segment));
@@ -61035,7 +61044,7 @@
                 },
                 conflictColumns: this.conflictColumnNames,
                 columns: this.columnNames,
-                rows: keys$9(entries).reduce((rows, key) => {
+                rows: keys$a(entries).reduce((rows, key) => {
                     const entry = entries[key];
                     rows.push([key, stringify$7(entry.data)]);
                     return rows;
@@ -62546,7 +62555,7 @@
             const draftService = new UiApiDraftRecordService(lazyDraftQueue, () => lazyLuvio, recordDenormingStore, getObjectInfo, newRecordId, userId, formatDisplayValue);
             const uiApiRecordHandler = new UiApiActionHandler(() => lazyLuvio, lazyNetworkAdapter, recordDenormingStore, lazyDraftQueue, getRecord, lazyObjectInfoService, isGenerated, draftService);
             const quickActionHandler = new QuickActionExecutionRepresentationHandler(() => lazyLuvio, draftService, lazyDraftQueue, lazyNetworkAdapter, isGenerated);
-            const contentDocumentCompositeActionHandler = new ContentDocumentCompositeRepresentationActionHandler(() => lazyLuvio, draftService, lazyDraftQueue, lazyNetworkAdapter, isGenerated, recordDenormingStore, NimbusBinaryStore);
+            const contentDocumentCompositeActionHandler = new ContentDocumentCompositeRepresentationActionHandler(() => lazyLuvio, draftService, lazyDraftQueue, lazyNetworkAdapter, isGenerated, NimbusBinaryStore);
             lazyDraftQueue.addHandler(uiApiRecordHandler);
             lazyDraftQueue.addHandler(quickActionHandler);
             lazyDraftQueue.addHandler(contentDocumentCompositeActionHandler);
@@ -62645,7 +62654,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$2,
     });
-    // version: 1.296.1-1aa7fc7e3
+    // version: 1.297.0-1fc775982
 
     const { create: create$3, keys: keys$3 } = Object;
     const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -82714,7 +82723,7 @@
         configuration: { ...configurationForGraphQLAdapters$1 },
         instrument: instrument$1,
     });
-    // version: 1.296.1-cf86708a0
+    // version: 1.297.0-e0cfbd880
 
     // On core the unstable adapters are re-exported with different names,
     // we want to match them here.
@@ -84970,7 +84979,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.296.1-cf86708a0
+    // version: 1.297.0-e0cfbd880
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -85705,7 +85714,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.296.1-1aa7fc7e3
+    // version: 1.297.0-1fc775982
 
     /**
      * Returns true if the value acts like a Promise, i.e. has a "then" function,
@@ -90686,4 +90695,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.296.1-1aa7fc7e3
+// version: 1.297.0-1fc775982