@salesforce/lds-runtime-bridge 1.296.0 → 1.297.0

package/dist/ldsRuntimeBridge.js

@@ -11,12 +11,10 @@
  *  Any changes made to this file in p4 will be automatically overwritten.
  *  *******************************************************************************************
  */
-import { setDefaultLuvio } from 'force/ldsEngine';
+import { register, setDefaultLuvio } from 'force/ldsEngine';
 import { setBypassDeepFreeze, StoreKeySet, serializeStructuredKey, StringKeyInMemoryStore, Reader, deepFreeze, emitAdapterEvent, InMemoryStore, Environment, Luvio } from 'force/luvioEngine';
 import { instrumentLuvio } from 'force/ldsInstrumentation';
-import { isStoreKeyRecordViewEntity, RECORD_ID_PREFIX, RECORD_FIELDS_KEY_JUNCTION, extractRecordIdFromStoreKey, RECORD_VIEW_ENTITY_ID_PREFIX, keyBuilderRecord } from 'native/ldsAdaptersUiapiMobile';
-import '@salesforce/gate/lds.idempotencyWriteDisabled';
-import '@salesforce/gate/lds.backdatingEnabled';
+import 'force/ldsGraphqlParser';
 import networkAdapter from 'force/ldsNetwork';
 import ldsEngineCreator from 'force/ldsEngineCreator';
 
@@ -42,7 +40,7 @@ const RedirectDurableSegment = 'REDIRECT_KEYS';
 const MessagingDurableSegment = 'MESSAGING';
 const MessageNotifyStoreUpdateAvailable = 'notifyStoreUpdateAvailable';
 
-const { keys: keys$2, create: create$2, assign: assign$2, freeze: freeze$1 } = Object;
+const { keys: keys$3, create: create$3, assign: assign$3, freeze: freeze$2 } = Object;
 
 //Durable store error instrumentation key
 const DURABLE_STORE_ERROR = 'durable-store-error';
@@ -92,7 +90,7 @@ function publishDurableStoreEntries(durableRecords, put, publishMetadata) {
     if (durableRecords === undefined) {
         return { revivedKeys, hadUnexpectedShape };
     }
-    const durableKeys = keys$2(durableRecords);
+    const durableKeys = keys$3(durableRecords);
     if (durableKeys.length === 0) {
         // no records to revive
         return { revivedKeys, hadUnexpectedShape };
@@ -277,7 +275,7 @@ class DurableTTLStore {
                     overrides,
                 };
             }
-            const keys$1 = keys$2(entries);
+            const keys$1 = keys$3(entries);
             for (let i = 0, len = keys$1.length; i < len; i++) {
                 const key = keys$1[i];
                 const entry = entries[key];
@@ -299,14 +297,14 @@ class DurableTTLStore {
 }
 
 function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler, redirects, additionalDurableStoreOperations = [], enableDurableMetadataRefresh = false) {
-    const durableRecords = create$2(null);
-    const refreshedDurableRecords = create$2(null);
-    const evictedRecords = create$2(null);
+    const durableRecords = create$3(null);
+    const refreshedDurableRecords = create$3(null);
+    const evictedRecords = create$3(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$2({ ...visitedIds, ...refreshedIds });
+    const keys$1 = keys$3({ ...visitedIds, ...refreshedIds });
     for (let i = 0, len = keys$1.length; i < len; i += 1) {
         const key = keys$1[i];
         const canonicalKey = store.getCanonicalRecordId(key);
@@ -329,7 +327,7 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
         setRecordTo(entries, key, record, metadata);
     }
     const durableStoreOperations = additionalDurableStoreOperations;
-    const recordKeys = keys$2(durableRecords);
+    const recordKeys = keys$3(durableRecords);
     if (recordKeys.length > 0) {
         // publishes with data
         durableStoreOperations.push({
@@ -338,7 +336,7 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
             segment: DefaultDurableSegment,
         });
     }
-    const refreshKeys = keys$2(refreshedDurableRecords);
+    const refreshKeys = keys$3(refreshedDurableRecords);
     if (refreshKeys.length > 0) {
         // publishes with only metadata updates
         durableStoreOperations.push({
@@ -360,7 +358,7 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
         });
     });
     // evicts
-    const evictedKeys = keys$2(evictedRecords);
+    const evictedKeys = keys$3(evictedRecords);
     if (evictedKeys.length > 0) {
         durableStoreOperations.push({
             type: 'evictEntries',
@@ -464,7 +462,7 @@ function buildRevivingStagingStore(upstreamStore) {
     // 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$2(upstreamStore, {
+    return create$3(upstreamStore, {
         readEntry: { value: readEntry },
         markStale: { value: markStale },
         clearStale: { value: clearStale },
@@ -476,7 +474,7 @@ const AdapterContextSegment = 'ADAPTER-CONTEXT';
 const ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
 async function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded) {
     // initialize empty context store
-    contextStores[adapterId] = create$2(null);
+    contextStores[adapterId] = create$3(null);
     const context = {
         set(key, value) {
             contextStores[adapterId][key] = value;
@@ -541,7 +539,7 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
     const revivingStores = new Set();
     // redirects that need to be flushed to the durable store
     const pendingStoreRedirects = new Map();
-    const contextStores = create$2(null);
+    const contextStores = create$3(null);
     let initializationPromise = new Promise((resolve) => {
         const finish = () => {
             resolve();
@@ -618,7 +616,7 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
             try {
                 const entries = await durableStore.getEntries(adapterContextKeysFromDifferentInstance, AdapterContextSegment);
                 if (entries !== undefined) {
-                    const entryKeys = keys$2(entries);
+                    const entryKeys = keys$3(entries);
                     for (let i = 0, len = entryKeys.length; i < len; i++) {
                         const entryKey = entryKeys[i];
                         const entry = entries[entryKey];
@@ -653,7 +651,7 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
             if (filteredKeys.length > 0) {
                 const entries = await durableStore.getMetadata(filteredKeys, DefaultDurableSegment);
                 if (entries !== undefined) {
-                    const entryKeys = keys$2(entries);
+                    const entryKeys = keys$3(entries);
                     for (let i = 0, len = entryKeys.length; i < len; i++) {
                         const entryKey = entryKeys[i];
                         const { metadata } = entries[entryKey];
@@ -1025,7 +1023,7 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
         validateNotDisposed();
         const entryKeys = keys$1.map(serializeStructuredKey);
         const entries = await durableStore.getEntries(entryKeys, DefaultDurableSegment);
-        if (entries === undefined || keys$2(entries).length === 0) {
+        if (entries === undefined || keys$3(entries).length === 0) {
             return environment.notifyStoreUpdateAvailable(keys$1);
         }
         const now = Date.now();
@@ -1077,7 +1075,7 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
         type: 'stale-while-revalidate',
         staleDurationSeconds: Number.MAX_SAFE_INTEGER,
     });
-    return create$2(environment, {
+    return create$3(environment, {
         publishStoreMetadata: { value: publishStoreMetadata },
         storeIngest: { value: storeIngest },
         storeIngestError: { value: storeIngestError },
@@ -1107,7 +1105,7 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
     });
 }
 
-const { keys: keys$1, create: create$1, assign: assign$1, entries: entries$1, values: values$1 } = Object;
+const { keys: keys$2, create: create$2, assign: assign$2, entries: entries$1, values: values$1 } = Object;
 const { stringify, parse } = JSON;
 
 function selectColumnsFromTableWhereKeyIn(columnNames, table, keyColumnName, whereIn) {
@@ -1174,7 +1172,7 @@ class LdsDataTable {
             },
             conflictColumns: this.conflictColumnNames,
             columns: this.columnNames,
-            rows: keys$1(entries).reduce((rows, key) => {
+            rows: keys$2(entries).reduce((rows, key) => {
                 const entry = entries[key];
                 const { data, metadata } = entry;
                 const row = [key, stringify(data), metadata ? stringify(metadata) : null];
@@ -1193,7 +1191,7 @@ class LdsDataTable {
                 type: 'setMetadata',
             },
             columns: [COLUMN_NAME_METADATA$1],
-            values: keys$1(entries).reduce((values, key) => {
+            values: keys$2(entries).reduce((values, key) => {
                 const { metadata } = entries[key];
                 const row = [metadata ? stringify(metadata) : null];
                 values[key] = row;
@@ -1283,7 +1281,7 @@ class LdsInternalDataTable {
             },
             conflictColumns: this.conflictColumnNames,
             columns: this.columnNames,
-            rows: keys$1(entries).reduce((rows, key) => {
+            rows: keys$2(entries).reduce((rows, key) => {
                 const entry = entries[key];
                 const { data, metadata } = entry;
                 const row = [key, stringify(data)];
@@ -1309,7 +1307,7 @@ class LdsInternalDataTable {
                 type: 'setMetadata',
             },
             columns: [COLUMN_NAME_METADATA],
-            values: keys$1(entries).reduce((values, key) => {
+            values: keys$2(entries).reduce((values, key) => {
                 const { metadata } = entries[key];
                 const row = [metadata ? stringify(metadata) : null];
                 values[key] = row;
@@ -1318,7 +1316,7 @@ class LdsInternalDataTable {
         };
     }
     metadataToUpdateSQLQueries(entries, segment) {
-        return keys$1(entries).reduce((accu, key) => {
+        return keys$2(entries).reduce((accu, key) => {
             const { metadata } = entries[key];
             if (metadata !== undefined) {
                 accu.push({
@@ -1389,7 +1387,7 @@ class NimbusSqliteStore {
         return this.getTable(segment).getAll(segment);
     }
     setEntries(entries, segment) {
-        if (keys$1(entries).length === 0) {
+        if (keys$2(entries).length === 0) {
             return Promise.resolve();
         }
         const table = this.getTable(segment);
@@ -1397,7 +1395,7 @@ class NimbusSqliteStore {
         return this.batchOperationAsPromise([upsertOperation]);
     }
     setMetadata(entries, segment) {
-        if (keys$1(entries).length === 0) {
+        if (keys$2(entries).length === 0) {
             return Promise.resolve();
         }
         const table = this.getTable(segment);
@@ -1416,13 +1414,13 @@ class NimbusSqliteStore {
     batchOperations(operations) {
         const sqliteOperations = operations.reduce((acc, cur) => {
             if (cur.type === 'setEntries') {
-                if (keys$1(cur.entries).length > 0) {
+                if (keys$2(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$1(cur.entries).length > 0) {
+                if (keys$2(cur.entries).length > 0) {
                     const table = this.getTable(cur.segment);
                     if (this.supportsBatchUpdates) {
                         acc.push(table.metadataToUpdateOperations(cur.entries, cur.segment));
@@ -1521,143 +1519,746 @@ class NimbusSqliteStore {
  */
 
 
-function isStoreKeyRecordId(key) {
-    return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1;
-}
-function buildRecordFieldStoreKey(recordKey, fieldName) {
-    return `${recordKey}${RECORD_FIELDS_KEY_JUNCTION}${fieldName}`;
-}
-
-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(key)) &&
-        entry.data.__type === undefined);
-}
-
 /**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
+ * Defines configuration for the module with a default value which can be overridden by the runtime environment.
  */
+/**
+ * Environment Aware GraphQLBatch adapter
+ */
+let environmentAwareGraphQLBatchAdapter = undefined;
+/**
+ * Draft-aware GraphQL adapter
+ */
+let draftAwareGraphQLAdapter = undefined;
+/**
+ * Draft-aware createRecord adapter
+ */
+let draftAwareCreateRecordAdapter = undefined;
+/**
+ * Draft-aware updateRecord adapter
+ */
+let draftAwareUpdateRecordAdapter = undefined;
+/**
+ * Draft-aware deleteRecord adapter
+ */
+let draftAwareDeleteRecordAdapter = undefined;
+/**
+ * Draft-aware createContentDocumentAndVersion adapter
+ */
+let draftAwareCreateContentDocumentAndVersionAdapter = undefined;
+/**
+ * Draft-aware createContentVersion adapter
+ */
+let draftAwareCreateContentVersionAdapter = undefined;
+/**
+ * Depth to which tracked fields will be added to a request that results from a cache miss.
+ * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
+ * be reached by following 1 relationship from the root record, etc.
+ * @defaultValue '5', replicates the current behavior
+ */
+let trackedFieldDepthOnCacheMiss = 5;
+/**
+ * Depth to which tracked fields will be added to a request that results from a merge conflict
+ * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
+ * be reached by following 1 relationship from the root record, etc.
+ * @defaultValue '5', replicates the current behavior
+ */
+let trackedFieldDepthOnCacheMergeConflict = 5;
+/**
+ * Depth to which tracked fields will be added to a request that results from a notify change invocation by the consumer
+ * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
+ * be reached by following 1 relationship from the root record, etc.
+ * @defaultValue '5', replicates the current behavior
+ */
+let trackedFieldDepthOnNotifyChange = 5;
+/**
+ * Determines if we will only fetch the 'Id' field for the leaf relationship record
+ * @defaultValue 'false', replicates the current behavior and fetches all fields in the store for the leaf relationship record
+ */
+let trackedFieldLeafNodeIdAndNameOnly = false;
+/**
+ * One store enabled Get Object Info adapter
+ */
+let oneStoreGetObjectInfoAdapter = undefined;
+/**
+ * One store enabled Get Object Infos adapter
+ */
+let oneStoreGetObjectInfosAdapter = undefined;
+/**
+ * Determines when to include PDL strategies for Related Lists
+ */
+let relatedListsPredictionsEnabled = false;
+/**
+ * Defines the configuration API and is exposed internally as well as externally.
+ * Configuration for one store enabled REST adapters only.
+ */
+const configurationForOneStoreEnabledAdapters = {
+    setGetObjectInfoAdapter: function (adapter) {
+        oneStoreGetObjectInfoAdapter = adapter;
+    },
+    getGetObjectInfoAdapter: function () {
+        return oneStoreGetObjectInfoAdapter;
+    },
+    setGetObjectInfosAdapter: function (adapter) {
+        oneStoreGetObjectInfosAdapter = adapter;
+    },
+    getGetObjectInfosAdapter: function () {
+        return oneStoreGetObjectInfosAdapter;
+    },
+};
+/**
+ * Defines the configuration API and is exposed internally as well as externally.
+ * Configuration for REST adapters only.
+ */
+const configurationForRestAdapters = {
+    setTrackedFieldDepthOnCacheMiss: function (trackedFieldDepthOnCacheMissParam) {
+        trackedFieldDepthOnCacheMiss = trackedFieldDepthOnCacheMissParam;
+    },
+    getTrackedFieldDepthOnCacheMiss: function () {
+        return trackedFieldDepthOnCacheMiss;
+    },
+    setTrackedFieldDepthOnCacheMergeConflict: function (trackedFieldDepthOnCacheMergeConflictParam) {
+        trackedFieldDepthOnCacheMergeConflict = trackedFieldDepthOnCacheMergeConflictParam;
+    },
+    getTrackedFieldDepthOnCacheMergeConflict: function () {
+        return trackedFieldDepthOnCacheMergeConflict;
+    },
+    setTrackedFieldDepthOnNotifyChange: function (trackedFieldDepthOnNotifyChangeParam) {
+        trackedFieldDepthOnNotifyChange = trackedFieldDepthOnNotifyChangeParam;
+    },
+    getTrackedFieldDepthOnNotifyChange: function () {
+        return trackedFieldDepthOnNotifyChange;
+    },
+    setTrackedFieldLeafNodeIdAndNameOnly: function (trackedFieldLeafNodeIdAndNameOnlyParam) {
+        trackedFieldLeafNodeIdAndNameOnly = trackedFieldLeafNodeIdAndNameOnlyParam;
+    },
+    getTrackedFieldLeafNodeIdAndNameOnly: function () {
+        return trackedFieldLeafNodeIdAndNameOnly;
+    },
+    // createRecord
+    setDraftAwareCreateRecordAdapter: function (adapter) {
+        draftAwareCreateRecordAdapter = adapter;
+    },
+    getDraftAwareCreateRecordAdapter: function () {
+        return draftAwareCreateRecordAdapter;
+    },
+    // updateRecord
+    setDraftAwareUpdateRecordAdapter: function (adapter) {
+        draftAwareUpdateRecordAdapter = adapter;
+    },
+    getDraftAwareUpdateRecordAdapter: function () {
+        return draftAwareUpdateRecordAdapter;
+    },
+    // deleteRecord
+    setDraftAwareDeleteRecordAdapter: function (adapter) {
+        draftAwareDeleteRecordAdapter = adapter;
+    },
+    getDraftAwareDeleteRecordAdapter: function () {
+        return draftAwareDeleteRecordAdapter;
+    },
+    // createContentDocumentAndVersion
+    setDraftAwareCreateContentDocumentAndVersionAdapter: function (adapter) {
+        draftAwareCreateContentDocumentAndVersionAdapter = adapter;
+    },
+    getDraftAwareCreateContentDocumentAndVersionAdapter: function () {
+        return draftAwareCreateContentDocumentAndVersionAdapter;
+    },
+    setRelatedListsPredictionsEnabled: function (f) {
+        relatedListsPredictionsEnabled = f;
+    },
+    areRelatedListsPredictionsEnabled: function () {
+        return relatedListsPredictionsEnabled === true;
+    },
+    // createContentVersion
+    setDraftAwareCreateContentVersionAdapter: function (adapter) {
+        draftAwareCreateContentVersionAdapter = adapter;
+    },
+    getDraftAwareCreateContentVersionAdapter: function () {
+        return draftAwareCreateContentVersionAdapter;
+    },
+    ...configurationForOneStoreEnabledAdapters,
+};
+/**
+ * Defines the configuration API and is exposed internally as well as externally.
+ * Configuration for GraphQL adapters only.
+ */
+const configurationForGraphQLAdapters = {
+    setDraftAwareGraphQLAdapter: function (adapter) {
+        draftAwareGraphQLAdapter = adapter;
+    },
+    getDraftAwareGraphQLAdapter: function () {
+        return draftAwareGraphQLAdapter;
+    },
+    setEnvironmentAwareGraphQLBatchAdapter: function (adapter) {
+        environmentAwareGraphQLBatchAdapter = adapter;
+    },
+    getEnvironmentAwareGraphQLBatchAdapter: function () {
+        return environmentAwareGraphQLBatchAdapter;
+    },
+};
+const registrations = new Set();
+/**
+ * lds-adapter-uiapi is special.  The non-SFDC bundle combines REST and GQL adapters,
+ * yet for SFDC those are separate bundles.  So non-SFDC bundle (./main.ts) registers
+ * both REST and GQL configs.  We want each SFDC bundle to register (we don't want one
+ * SFDC bundle to assume the other is being loaded and therefore the other one will
+ * take care of registration) but we don't want to double register either.
+ *
+ * So we make this function that memoizes if it's been called before and only
+ * actually registers once.
+ */
+function ensureRegisteredOnce(registration) {
+    const { id } = registration;
+    if (!registrations.has(id)) {
+        register(registration);
+        registrations.add(id);
+    }
+}
 
-
-var DraftActionStatus;
-(function (DraftActionStatus) {
-    DraftActionStatus["Pending"] = "pending";
-    DraftActionStatus["Uploading"] = "uploading";
-    DraftActionStatus["Error"] = "error";
-    DraftActionStatus["Completed"] = "completed";
-})(DraftActionStatus || (DraftActionStatus = {}));
-var ProcessActionResult;
-(function (ProcessActionResult) {
-    // non-2xx network error, requires user intervention
-    ProcessActionResult["ACTION_ERRORED"] = "ERROR";
-    // upload succeeded
-    ProcessActionResult["ACTION_SUCCEEDED"] = "SUCCESS";
-    // queue is empty
-    ProcessActionResult["NO_ACTION_TO_PROCESS"] = "NO_ACTION_TO_PROCESS";
-    // network request is in flight
-    ProcessActionResult["ACTION_ALREADY_PROCESSING"] = "ACTION_ALREADY_PROCESSING";
-    // network call failed (offline)
-    ProcessActionResult["NETWORK_ERROR"] = "NETWORK_ERROR";
-    // queue is blocked on an error that requires user intervention
-    ProcessActionResult["BLOCKED_ON_ERROR"] = "BLOCKED_ON_ERROR";
-    //waiting for user to execute custom action
-    ProcessActionResult["CUSTOM_ACTION_WAITING"] = "CUSTOM_ACTION_WAITING";
-})(ProcessActionResult || (ProcessActionResult = {}));
-var DraftQueueState;
-(function (DraftQueueState) {
-    /** Currently processing an item in the queue or queue is empty and waiting to process the next item. */
-    DraftQueueState["Started"] = "started";
-    /**
-     * The queue is stopped and will not attempt to upload any drafts until startDraftQueue() is called.
-     * This is the initial state when the DraftQueue gets instantiated.
-     */
-    DraftQueueState["Stopped"] = "stopped";
-    /**
-     * The queue is stopped due to a blocking error from the last upload attempt.
-     * The queue will not run again until startDraftQueue() is called.
-     */
-    DraftQueueState["Error"] = "error";
-    /**
-     * There was a network error and the queue will attempt to upload again shortly.
-     * To attempt to force an upload now call startDraftQueue().
-     */
-    DraftQueueState["Waiting"] = "waiting";
-})(DraftQueueState || (DraftQueueState = {}));
-var DraftQueueEventType;
-(function (DraftQueueEventType) {
-    /**
-     * Triggered after an action had been added to the queue
-     */
-    DraftQueueEventType["ActionAdded"] = "added";
+// For use by callers within this module to instrument interesting things.
+let instrumentation = {
     /**
-     * Triggered when starting to upload and process an action
+     * Called when a set of record conflicts has been fully resolved. The
+     * parameter indicates the number of server requests that were needed
+     * to fully resolve all the record conflicts.
      */
-    DraftQueueEventType["ActionUploading"] = "uploading";
+    recordConflictsResolved: (_serverRequestCount) => { },
     /**
-     * Triggered once an action failed
+     * Called during merging of incoming and existing FieldValues.
+     * Called when the incoming FieldValue display value is null.
+     *
+     * Note: Temporary instrumentation to capture distribution and frequency, W-8990630
+     * Flipped to counter metric due to W-9611107
      */
-    DraftQueueEventType["ActionFailed"] = "failed";
+    nullDisplayValueConflict: (_fieldInfo) => { },
     /**
-     * Triggered after an action has been deleted from the queue
+     * SFDC Throttling
+     * getRecordNotifyChange and notifyRecordUpdateAvailable are both throttled
      */
-    DraftQueueEventType["ActionDeleted"] = "deleted";
+    getRecordNotifyChangeAllowed: () => { },
+    getRecordNotifyChangeDropped: () => { },
+    notifyRecordUpdateAvailableAllowed: () => { },
+    notifyRecordUpdateAvailableDropped: () => { },
     /**
-     * Triggered after an action has been completed and after it has been removed from the queue
+     * RecordRepresentation merge
+     * Called when records change apiName
      */
-    DraftQueueEventType["ActionCompleted"] = "completed";
+    recordApiNameChanged: (_existingApiName, _incomingApiName) => { },
+    recordTypeIdIsNull: (_apiName) => { },
     /**
-     * Triggered after an action has been updated by the updateAction API
+     * RecordRepresentation merge
+     * Called when either incoming or existing RecordRepresentation has a weakEtag=0
      */
-    DraftQueueEventType["ActionUpdated"] = "updated";
+    weakEtagZero: (_incomingWeakEtagZero, _existingWeakEtagZero, _apiName) => { },
     /**
-     * Triggered after the Draft Queue state changes
+     * getRecord notifyChangeFactory
+     * Called when dispatchResourceRequest is resolved/rejected
      */
-    DraftQueueEventType["QueueStateChanged"] = "state";
-})(DraftQueueEventType || (DraftQueueEventType = {}));
-var QueueOperationType;
-(function (QueueOperationType) {
-    QueueOperationType["Add"] = "add";
-    QueueOperationType["Delete"] = "delete";
-    QueueOperationType["Update"] = "update";
-})(QueueOperationType || (QueueOperationType = {}));
-
-var CustomActionResultType;
-(function (CustomActionResultType) {
-    CustomActionResultType["SUCCESS"] = "SUCCESS";
-    CustomActionResultType["FAILURE"] = "FAILURE";
-})(CustomActionResultType || (CustomActionResultType = {}));
-var CustomActionErrorType;
-(function (CustomActionErrorType) {
-    CustomActionErrorType["NETWORK_ERROR"] = "NETWORK_ERROR";
-    CustomActionErrorType["CLIENT_ERROR"] = "CLIENT_ERROR";
-})(CustomActionErrorType || (CustomActionErrorType = {}));
+    getRecordNotifyChangeNetworkResult: (_uniqueWeakEtags, _error) => { },
+};
+/**
+ * Allows external modules (typically a runtime environment) to set
+ * instrumentation hooks for this module. Note that the hooks are
+ * incremental - hooks not suppiled in newInstrumentation will retain
+ * their previous values. The default instrumentation hooks are no-ops.
+ *
+ * @param newInstrumentation instrumentation hooks to be overridden
+ */
+function instrument(newInstrumentation) {
+    instrumentation = Object.assign(instrumentation, newInstrumentation);
+}
+const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
+function generateParamConfigMetadata(name, required, resourceType, typeCheckShape, isArrayShape = false, coerceFn) {
+    return {
+        name,
+        required,
+        resourceType,
+        typeCheckShape,
+        isArrayShape,
+        coerceFn,
+    };
+}
+function buildAdapterValidationConfig(displayName, paramsMeta) {
+    const required = paramsMeta.filter(p => p.required).map(p => p.name);
+    const optional = paramsMeta.filter(p => !p.required).map(p => p.name);
+    return {
+        displayName,
+        parameters: {
+            required,
+            optional,
+        }
+    };
+}
+const keyPrefix = 'UiApi';
+
+const { assign: assign$1, create: create$1, freeze: freeze$1, isFrozen, keys: keys$1 } = Object;
+const { isArray } = Array;
+const { concat, filter, includes, push, reduce } = Array.prototype;
+
+function isString(value) {
+    return typeof value === 'string';
+}
+/**
+ * @param value The array to dedupe
+ * @returns An array without duplicates.
+ */
+function dedupe(value) {
+    const result = {};
+    for (let i = 0, len = value.length; i < len; i += 1) {
+        result[value[i]] = true;
+    }
+    return keys$1(result);
+}
+
+function isObjectId(unknown) {
+    if (typeof unknown !== 'object' || unknown === null) {
+        return false;
+    }
+    return isString(unknown.objectApiName);
+}
+
+/**
+ * Returns the object API name.
+ * @param value The value from which to get the object API name.
+ * @returns The object API name.
+ */
+function getObjectApiName$1(value) {
+    // Note: tightening validation logic changes behavior from userland getting
+    // a server-provided error to the adapter noop'ing. In 224 we decided to not
+    // change the behavior.
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed.length > 0) {
+            return trimmed;
+        }
+    }
+    else if (isObjectId(value)) {
+        return value.objectApiName.trim();
+    }
+    return undefined;
+}
+
+function isFieldId(unknown) {
+    if (typeof unknown !== 'object' || unknown === null) {
+        return false;
+    }
+    const value = unknown;
+    return isString(value.objectApiName) && isString(value.fieldApiName);
+}
+
+/**
+ * Returns the field API name, qualified with an object name if possible.
+ * @param value The value from which to get the qualified field API name.
+ * @param onlyQualifiedFieldNames - Whether or not this function should skip fieldApiName that do not include the delimiter '.'
+ * @return The qualified field API name.
+ */
+function getFieldApiName(value, onlyQualifiedFieldNames = false) {
+    // Note: tightening validation logic changes behavior from userland getting
+    // a server-provided error to the adapter noop'ing. In 224 we decided to not
+    // change the behavior. In 250 we decided to add the 'onlyQualifiedFieldName' flag to tighten the logic
+    // optionally to avoid issues with persisted invalid field names.
+    if (isString(value)) {
+        const trimmed = value.trim();
+        if (trimmed.length > 0 && (onlyQualifiedFieldNames ? trimmed.indexOf('.') > -1 : true)) {
+            return trimmed;
+        }
+    }
+    else if (isFieldId(value)) {
+        return value.objectApiName + '.' + value.fieldApiName;
+    }
+    return undefined;
+}
 
 /**
- * Denotes what kind of operation a DraftQueueItem represents.
+ * Returns the field API name.
+ * @param value The value from which to get the field API name.
+ * @param options Option bag. onlyQualifiedFieldNames is a boolean that allows this function to skip returning invalid FieldApiNames.
+ * @returns The field API name.
  */
-var DraftActionOperationType;
-(function (DraftActionOperationType) {
-    DraftActionOperationType["Create"] = "create";
-    DraftActionOperationType["Update"] = "update";
-    DraftActionOperationType["Delete"] = "delete";
-    DraftActionOperationType["Custom"] = "custom";
-})(DraftActionOperationType || (DraftActionOperationType = {}));
-var DraftQueueOperationType;
-(function (DraftQueueOperationType) {
-    DraftQueueOperationType["ItemAdded"] = "added";
-    DraftQueueOperationType["ItemUploading"] = "uploading";
-    DraftQueueOperationType["ItemDeleted"] = "deleted";
-    DraftQueueOperationType["ItemCompleted"] = "completed";
-    DraftQueueOperationType["ItemFailed"] = "failed";
-    DraftQueueOperationType["ItemUpdated"] = "updated";
-    DraftQueueOperationType["QueueStarted"] = "started";
-    DraftQueueOperationType["QueueStopped"] = "stopped";
-})(DraftQueueOperationType || (DraftQueueOperationType = {}));
+function getFieldApiNamesArray(value, options = { onlyQualifiedFieldNames: false }) {
+    const valueArray = isArray(value) ? value : [value];
+    const array = [];
+    for (let i = 0, len = valueArray.length; i < len; i += 1) {
+        const item = valueArray[i];
+        const apiName = getFieldApiName(item, options.onlyQualifiedFieldNames);
+        if (apiName === undefined) {
+            if (options.onlyQualifiedFieldNames) {
+                continue; // Just skips invalid field names rather than failing to return an array at all
+            }
+            return undefined;
+        }
+        push.call(array, apiName);
+    }
+    if (array.length === 0) {
+        return undefined;
+    }
+    return dedupe(array).sort();
+}
+const RepresentationType$Z = 'RecordRepresentation';
+function keyBuilder$3r(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$Z + ':' + config.recordId;
+}
+freeze$1({
+    name: '',
+    children: {},
+});
+
+ObjectCreate$1(null);
+
+ObjectCreate$1(null);
+
+const adapterName$$ = 'getListUiByApiName';
+const getListUiByApiName_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('listViewApiName', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('objectApiName', true, 0 /* UrlParameter */, 0 /* String */, false, getObjectApiName$1),
+    generateParamConfigMetadata('fields', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+    generateParamConfigMetadata('optionalFields', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+    generateParamConfigMetadata('pageSize', false, 1 /* QueryParameter */, 3 /* Integer */),
+    generateParamConfigMetadata('pageToken', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('sortBy', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+];
+const getListUiByApiName_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$$, getListUiByApiName_ConfigPropertyMetadata);
+
+const adapterName$_ = 'getListUiByListViewId';
+const getListUiByListViewId_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('listViewId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('fields', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+    generateParamConfigMetadata('optionalFields', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+    generateParamConfigMetadata('pageSize', false, 1 /* QueryParameter */, 3 /* Integer */),
+    generateParamConfigMetadata('pageToken', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('sortBy', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+];
+const getListUiByListViewId_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$_, getListUiByListViewId_ConfigPropertyMetadata);
+
+const adapterName$Y = 'getMruListUi';
+const getMruListUi_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('objectApiName', true, 0 /* UrlParameter */, 0 /* String */, false, getObjectApiName$1),
+    generateParamConfigMetadata('fields', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+    generateParamConfigMetadata('optionalFields', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+    generateParamConfigMetadata('pageSize', false, 1 /* QueryParameter */, 3 /* Integer */),
+    generateParamConfigMetadata('pageToken', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('sortBy', false, 1 /* QueryParameter */, 0 /* String */, true, getFieldApiNamesArray),
+];
+const getMruListUi_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$Y, getMruListUi_ConfigPropertyMetadata);
+// make local copies of the adapter configs so we can ignore other getListUi config parameters to match
+// lds222 behavior
+({
+    ...getMruListUi_ConfigPropertyNames,
+    parameters: {
+        ...getMruListUi_ConfigPropertyNames.parameters,
+        optional: [
+            ...getMruListUi_ConfigPropertyNames.parameters.optional,
+            'listViewApiName',
+            'listViewId',
+        ],
+    },
+});
+// make local copies of the adapter configs so we can have them ignore each other's config parameters
+// to match lds222 behavior
+({
+    ...getListUiByApiName_ConfigPropertyNames,
+    parameters: {
+        ...getListUiByApiName_ConfigPropertyNames.parameters,
+        optional: [...getListUiByApiName_ConfigPropertyNames.parameters.optional, 'listViewId'],
+    },
+});
+({
+    ...getListUiByListViewId_ConfigPropertyNames,
+    parameters: {
+        ...getListUiByListViewId_ConfigPropertyNames.parameters,
+        optional: [
+            ...getListUiByListViewId_ConfigPropertyNames.parameters.optional,
+            'listViewApiName',
+            'objectApiName',
+        ],
+    },
+});
+
+var DiscriminatorValues$5;
+(function (DiscriminatorValues) {
+    DiscriminatorValues["EmptySpace"] = "EmptySpace";
+    DiscriminatorValues["ReportChart"] = "ReportChart";
+    DiscriminatorValues["VisualforcePage"] = "VisualforcePage";
+    DiscriminatorValues["Canvas"] = "Canvas";
+    DiscriminatorValues["Field"] = "Field";
+    DiscriminatorValues["CustomLink"] = "CustomLink";
+})(DiscriminatorValues$5 || (DiscriminatorValues$5 = {}));
+
+var LayoutMode;
+(function (LayoutMode) {
+    LayoutMode["View"] = "View";
+    LayoutMode["Edit"] = "Edit";
+    LayoutMode["Create"] = "Create";
+})(LayoutMode || (LayoutMode = {}));
+
+LayoutMode.View;
+
+var FormFactor;
+(function (FormFactor) {
+    FormFactor["Large"] = "Large";
+    FormFactor["Medium"] = "Medium";
+    FormFactor["Small"] = "Small";
+})(FormFactor || (FormFactor = {}));
+
+ObjectCreate$1(null);
+
+var LayoutType;
+(function (LayoutType) {
+    LayoutType["Full"] = "Full";
+    LayoutType["Compact"] = "Compact";
+})(LayoutType || (LayoutType = {}));
+
+ObjectCreate$1(null);
+
+ObjectCreate$1(null);
+
+const VERSION$1S = "8d2032474fb4fabdf5cf4042be9042d9";
+const select$24 = function WorkStepPicklistValueAttributeRepresentationSelect() {
+    const { selections: AbstractPicklistValueAttributesRepresentationSelections } = select$20();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1S,
+        private: [],
+        selections: [
+            ...AbstractPicklistValueAttributesRepresentationSelections,
+            {
+                name: 'sortOrder',
+                kind: 'Scalar'
+            },
+            {
+                name: 'statusCode',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+
+const VERSION$1R = "53893a219bc0888951863f2c44317cac";
+const select$23 = function LeadStatusPicklistValueAttributesRepresentationSelect() {
+    const { selections: AbstractPicklistValueAttributesRepresentationSelections } = select$20();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1R,
+        private: [],
+        selections: [
+            ...AbstractPicklistValueAttributesRepresentationSelections,
+            {
+                name: 'converted',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+
+const VERSION$1Q = "4818ec07c499784571c1012ead048c88";
+const select$22 = function CaseStatusPicklistValueAttributesRepresentationSelect() {
+    const { selections: AbstractPicklistValueAttributesRepresentationSelections } = select$20();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1Q,
+        private: [],
+        selections: [
+            ...AbstractPicklistValueAttributesRepresentationSelections,
+            {
+                name: 'closed',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+
+const VERSION$1P = "950a3a962acbd2b128f937d4c055a9d6";
+const select$21 = function OpportunityStagePicklistValueAttributesRepresentationSelect() {
+    const { selections: AbstractPicklistValueAttributesRepresentationSelections } = select$20();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1P,
+        private: [],
+        selections: [
+            ...AbstractPicklistValueAttributesRepresentationSelections,
+            {
+                name: 'closed',
+                kind: 'Scalar'
+            },
+            {
+                name: 'defaultProbability',
+                kind: 'Scalar'
+            },
+            {
+                name: 'forecastCategoryName',
+                kind: 'Scalar'
+            },
+            {
+                name: 'won',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+
+var DiscriminatorValues$4;
+(function (DiscriminatorValues) {
+    DiscriminatorValues["WorkStepStatus"] = "WorkStepStatus";
+    DiscriminatorValues["LeadStatus"] = "LeadStatus";
+    DiscriminatorValues["CaseStatus"] = "CaseStatus";
+    DiscriminatorValues["OpportunityStage"] = "OpportunityStage";
+})(DiscriminatorValues$4 || (DiscriminatorValues$4 = {}));
+const VERSION$1O = "bd523b2343366edfc25a2dbee2c4e986";
+const selectChildren$2 = function AbstractPicklistValueAttributesRepresentationSelectChildren() {
+    const workStepPicklistValueAttributeRepresentationSelections = select$24();
+    const leadStatusPicklistValueAttributesRepresentationSelections = select$23();
+    const caseStatusPicklistValueAttributesRepresentationSelections = select$22();
+    const opportunityStagePicklistValueAttributesRepresentationSelections = select$21();
+    return {
+        kind: 'Fragment',
+        union: true,
+        discriminator: 'picklistAtrributesValueType',
+        unionSelections: {
+            [DiscriminatorValues$4.WorkStepStatus]: workStepPicklistValueAttributeRepresentationSelections,
+            [DiscriminatorValues$4.LeadStatus]: leadStatusPicklistValueAttributesRepresentationSelections,
+            [DiscriminatorValues$4.CaseStatus]: caseStatusPicklistValueAttributesRepresentationSelections,
+            [DiscriminatorValues$4.OpportunityStage]: opportunityStagePicklistValueAttributesRepresentationSelections
+        }
+    };
+};
+const select$20 = function AbstractPicklistValueAttributesRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$1O,
+        private: [],
+        selections: [
+            {
+                name: 'picklistAtrributesValueType',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+
+const VERSION$1N = "9e2a16a80378487f557124c771201cf9";
+const select$1$ = function PicklistValueRepresentationSelect() {
+    const AbstractPicklistValueAttributesRepresentation__unionSelections = selectChildren$2();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1N,
+        private: [],
+        selections: [
+            {
+                kind: 'Object',
+                name: 'attributes',
+                discriminator: AbstractPicklistValueAttributesRepresentation__unionSelections.discriminator,
+                union: true,
+                nullable: true,
+                unionSelections: AbstractPicklistValueAttributesRepresentation__unionSelections.unionSelections
+            },
+            {
+                name: 'label',
+                kind: 'Scalar'
+            },
+            {
+                name: 'validFor',
+                kind: 'Scalar',
+                plural: true
+            },
+            {
+                name: 'value',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+const VERSION$1M = "0a361a49370acb4c6a31721a2057649a";
+const select$1_ = function PicklistValuesRepresentationSelect() {
+    const { selections: PicklistValueRepresentation__selections, opaque: PicklistValueRepresentation__opaque, } = select$1$();
+    return {
+        kind: 'Fragment',
+        version: VERSION$1M,
+        private: [
+            'eTag'
+        ],
+        selections: [
+            {
+                name: 'controllerValues',
+                kind: 'Scalar',
+                map: true
+            },
+            {
+                name: 'defaultValue',
+                kind: 'Object',
+                nullable: true,
+                selections: PicklistValueRepresentation__selections
+            },
+            {
+                name: 'url',
+                kind: 'Scalar'
+            },
+            {
+                name: 'values',
+                kind: 'Object',
+                plural: true,
+                selections: PicklistValueRepresentation__selections
+            }
+        ]
+    };
+};
+
+select$1_().selections;
+
+var DiscriminatorValues$3;
+(function (DiscriminatorValues) {
+    DiscriminatorValues["Photo"] = "Photo";
+    DiscriminatorValues["Theme"] = "Theme";
+})(DiscriminatorValues$3 || (DiscriminatorValues$3 = {}));
+
+ObjectCreate$1(null);
+
+ObjectCreate$1(null);
+
+ObjectCreate$1(null);
+
+ObjectCreate$1(null);
+
+var DiscriminatorValues$1;
+(function (DiscriminatorValues) {
+    DiscriminatorValues["Text"] = "Text";
+    DiscriminatorValues["Select"] = "Select";
+})(DiscriminatorValues$1 || (DiscriminatorValues$1 = {}));
+
+var DiscriminatorValues;
+(function (DiscriminatorValues) {
+    DiscriminatorValues["Field"] = "Field";
+    DiscriminatorValues["DataCategory"] = "DataCategory";
+})(DiscriminatorValues || (DiscriminatorValues = {}));
+
+const API_NAMESPACE = 'UiApi';
+const RECORD_REPRESENTATION_NAME = 'RecordRepresentation';
+const RECORD_VIEW_ENTITY_REPRESENTATION_NAME = 'RecordViewEntityRepresentation';
+const RECORD_ID_PREFIX = `${API_NAMESPACE}::${RECORD_REPRESENTATION_NAME}:`;
+const RECORD_VIEW_ENTITY_ID_PREFIX = `${API_NAMESPACE}::${RECORD_VIEW_ENTITY_REPRESENTATION_NAME}:Name:`;
+const RECORD_FIELDS_KEY_JUNCTION = '__fields__';
+function extractRecordIdFromStoreKey(key) {
+    if (key === undefined ||
+        (key.indexOf(RECORD_ID_PREFIX) === -1 && key.indexOf(RECORD_VIEW_ENTITY_ID_PREFIX) === -1)) {
+        return undefined;
+    }
+    const parts = key.split(':');
+    return parts[parts.length - 1].split('_')[0];
+}
+function isStoreKeyRecordViewEntity(key) {
+    return (key.indexOf(RECORD_VIEW_ENTITY_ID_PREFIX) > -1 &&
+        key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1);
+}
+// The rest of this is copy-pasted. Sorry.
+ObjectCreate$1(null);
+ensureRegisteredOnce({
+    id: '@salesforce/lds-adapters-uiapi',
+    configuration: {
+        ...configurationForRestAdapters,
+        ...configurationForGraphQLAdapters,
+        ...configurationForOneStoreEnabledAdapters,
+    },
+    instrument,
+});
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -1668,9 +2269,23 @@ var DraftQueueOperationType;
 
 const { keys, values, create, assign, freeze, entries } = Object;
 
+function buildRecordFieldStoreKey(recordKey, fieldName) {
+    return `${recordKey}${RECORD_FIELDS_KEY_JUNCTION}${fieldName}`;
+}
+function isStoreKeyRecordId(key) {
+    return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1;
+}
 function createLink(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(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
@@ -1778,7 +2393,7 @@ function getDenormalizedKey(originalKey, recordId, luvio) {
     if (originalKey.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX)) {
         return RECORD_VIEW_ENTITY_ID_PREFIX + recordId;
     }
-    return keyBuilderRecord(luvio, { recordId });
+    return keyBuilder$3r(luvio, { recordId });
 }
 function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecords, getStoreMetadata, getStore, sqlStore) {
     const getEntries = function (entries, segment) {
@@ -2085,4 +2700,4 @@ function ldsRuntimeBridge() {
 }
 
 export { ldsRuntimeBridge as default };
-// version: 1.296.0-ad26368c0
+// version: 1.297.0-1fc775982

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-bridge",
-    "version": "1.296.0",
+    "version": "1.297.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS runtime for bridge.app.",
     "main": "dist/ldsRuntimeBridge.js",
@@ -34,17 +34,16 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-bridge"
     },
     "dependencies": {
-        "@salesforce/lds-adapters-uiapi-mobile": "^1.296.0",
-        "@salesforce/lds-instrumentation": "^1.296.0",
+        "@salesforce/lds-durable-records": "^1.297.0",
+        "@salesforce/lds-instrumentation": "^1.297.0",
         "@salesforce/user": "0.0.21",
         "o11y": "250.7.0"
     },
     "devDependencies": {
-        "@salesforce/lds-drafts-adapters-uiapi": "^1.296.0",
-        "@salesforce/lds-network-aura": "^1.296.0",
-        "@salesforce/lds-runtime-aura": "^1.296.0",
-        "@salesforce/lds-store-nimbus": "^1.296.0",
-        "@salesforce/nimbus-plugin-lds": "^1.296.0",
+        "@salesforce/lds-network-aura": "^1.297.0",
+        "@salesforce/lds-runtime-aura": "^1.297.0",
+        "@salesforce/lds-store-nimbus": "^1.297.0",
+        "@salesforce/nimbus-plugin-lds": "^1.297.0",
         "babel-plugin-dynamic-import-node": "^2.3.3"
     },
     "luvioBundlesize": [