@salesforce/lds-worker-api 1.433.0 → 1.435.0

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

@@ -4274,7 +4274,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.433.0-8a15a98f24
+// version: 1.435.0-5818ce3c48
 
 // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
 function instrumentAdapter$1(createFunction, _metadata) {
@@ -5318,7 +5318,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     const { apiFamily, name } = metadata;
     return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
-// version: 1.433.0-8a15a98f24
+// version: 1.435.0-5818ce3c48
 
 function isSupportedEntity(_objectApiName) {
     return true;
@@ -5455,28 +5455,23 @@ let configurableCreateContentVersion$3 = new Configurable$3();
  * Depth to which tracked fields will be added to a request that results from a cache miss.
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMiss$3 = 5;
+let trackedFieldDepthOnCacheMiss$3 = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a merge conflict
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMergeConflict$3 = 5;
+let trackedFieldDepthOnCacheMergeConflict$3 = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a notify change invocation by the consumer
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnNotifyChange$3 = 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$3 = false;
+let trackedFieldDepthOnNotifyChange$3 = 1;
 /**
  * One store enabled Get Object Info adapter
  */
@@ -5573,12 +5568,6 @@ const configurationForEnvironmentFactoryOverrides$3 = {
     getTrackedFieldDepthOnNotifyChange: function () {
         return trackedFieldDepthOnNotifyChange$3;
     },
-    setTrackedFieldLeafNodeIdAndNameOnly: function (trackedFieldLeafNodeIdAndNameOnlyParam) {
-        trackedFieldLeafNodeIdAndNameOnly$3 = trackedFieldLeafNodeIdAndNameOnlyParam;
-    },
-    getTrackedFieldLeafNodeIdAndNameOnly: function () {
-        return trackedFieldLeafNodeIdAndNameOnly$3;
-    },
     setRecordRepresentationIngestionOverride: function (ingest) {
         recordRepresentationIngestionOverride$3 = ingest;
     },
@@ -5700,28 +5689,23 @@ let configurableCreateContentVersion$2 = new Configurable$2();
  * Depth to which tracked fields will be added to a request that results from a cache miss.
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMiss$2 = 5;
+let trackedFieldDepthOnCacheMiss$2 = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a merge conflict
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMergeConflict$2 = 5;
+let trackedFieldDepthOnCacheMergeConflict$2 = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a notify change invocation by the consumer
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnNotifyChange$2 = 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$2 = false;
+let trackedFieldDepthOnNotifyChange$2 = 1;
 /**
  * One store enabled Get Object Info adapter
  */
@@ -5827,12 +5811,6 @@ const configurationForRestAdapters$2 = {
     getTrackedFieldDepthOnNotifyChange: function () {
         return trackedFieldDepthOnNotifyChange$2;
     },
-    setTrackedFieldLeafNodeIdAndNameOnly: function (trackedFieldLeafNodeIdAndNameOnlyParam) {
-        trackedFieldLeafNodeIdAndNameOnly$2 = trackedFieldLeafNodeIdAndNameOnlyParam;
-    },
-    getTrackedFieldLeafNodeIdAndNameOnly: function () {
-        return trackedFieldLeafNodeIdAndNameOnly$2;
-    },
     setRecordRepresentationIngestionOverride: function (ingest) {
         recordRepresentationIngestionOverride$2 = ingest;
     },
@@ -7673,6 +7651,9 @@ function buildSelectionFromRecord$1(record) {
     return [...sel.selections, DRAFTS_SELECTION$1];
 }
 
+// Unused suffixes, but leaving in as comments to avoid eslint errors
+// const CUSTOM_API_NAME_SUFFIX = '__c';
+// const DMO_API_NAME_SUFFIX = '__dlm';
 const CUSTOM_EXTERNAL_OBJECT_FIELD_SUFFIX$1 = '__x';
 const RECORD_REPRESENTATION_ERROR_VERSION$1 = 'RECORD_REPRESENTATION_ERROR_VERSION_1';
 const RECORD_REPRESENTATION_ERROR_STORE_METADATA_PARAMS$1 = {
@@ -7736,13 +7717,11 @@ function extractTrackedFieldsToTrie$1(recordId, node, root, config, visitedRecor
             if (!isGraphNode$1(field)) {
                 continue;
             }
-            const { maxDepth, onlyFetchLeafNodeIdAndName } = config;
+            const { maxDepth } = config;
             if (field.isScalar('value') === false && !Array.isArray(field.data?.value)) {
                 if (depth + 1 > maxDepth) {
-                    if (onlyFetchLeafNodeIdAndName === true) {
-                        addScalarFieldId$1(current);
-                        addScalarFieldName$1(current);
-                    }
+                    addScalarFieldId$1(current);
+                    addScalarFieldName$1(current);
                     continue;
                 }
                 const spanningLink = field.link('value');
@@ -7764,19 +7743,10 @@ function extractTrackedFieldsToTrie$1(recordId, node, root, config, visitedRecor
                 current.children[key] = next;
             }
             else {
-                // Skip the field, if its value is null at the max level depth.
-                // Ideally, it should only skip relationship field. However,
-                // on the client, there is not a reliable way to determine the
-                // the field type.
                 if (depth === maxDepth) {
-                    if (onlyFetchLeafNodeIdAndName === true) {
-                        addScalarFieldId$1(current);
-                        addScalarFieldName$1(current);
-                        continue;
-                    }
-                    if (field.scalar('value') === null && !Array.isArray(field.data?.value)) {
-                        continue;
-                    }
+                    addScalarFieldId$1(current);
+                    addScalarFieldName$1(current);
+                    continue;
                 }
                 const state = fieldValueRep.linkData();
                 if (state !== undefined) {
@@ -8162,7 +8132,6 @@ function mergeRecordConflict$1(luvio, incoming, existing, recordConflictMap) {
     };
     const trackedFieldsConfig = {
         maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMergeConflict(),
-        onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
     };
     extractTrackedFieldsToTrie$1(recordKey, incomingNode, incomingTrackedFieldsTrieRoot, trackedFieldsConfig);
     extractTrackedFieldsToTrie$1(recordKey, existingNode, existingTrackedFieldsTrieRoot, trackedFieldsConfig);
@@ -8606,7 +8575,6 @@ function prepareRequest$7(luvio, config) {
     const key = keyBuilder$28(luvio, createResourceParams$12(config));
     const allTrackedFields = getTrackedFields$1(key, luvio.getNode(key), {
         maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-        onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
     }, config.optionalFields);
     const optionalFields = fields === undefined ? allTrackedFields : difference$1(allTrackedFields, fields);
     const resourceParams = createResourceParams$12({
@@ -8733,7 +8701,6 @@ function ingestSuccessChildResourceParams$8(luvio, childResourceParamsArray, chi
             };
             const childTrackedFields = getTrackedFields$1(childKey, luvio.getNode(childKey), {
                 maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-                onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
             }, childResourceParams.queryParams.optionalFields);
             const childSnapshot = ingestSuccess$S(luvio, {
                 recordId: childResourceParams.urlParams.recordId,
@@ -12965,17 +12932,15 @@ function getRelationshipName$1(objectInfo, fieldApiName) {
     return objectInfo.fields[fieldApiName].relationshipName;
 }
 function getNameField$1(objectInfo, fieldApiName) {
-    // eslint-disable-next-line @salesforce/lds/no-invalid-todo
-    // TODO - this logic is adopted from lds222. It searches
-    // ObjectInfoRep.ReferenceToInfoRep[].nameFields[]:
-    // 1. If any of the arrays are empty returns `Name`
-    // 2. If `Name` is found in any array position then returns it
-    // 3. If the field has more than 1 references(polymorphic), return `Name`
-    // 4. Else returns ObjectInfoRep.ReferenceToInfoRep[0].nameFields[0]
-    // Rationale for this is unclear and needs clarification.
     const referenceToInfos = objectInfo.fields[fieldApiName].referenceToInfos;
     if (referenceToInfos.length !== 1) {
-        return FIELD_NAME$1;
+        // For polymorphic fields, return "Name" only if at least one referenced entity has it.
+        // If no entity in the domain set has a Name field (e.g. ContextTag uses "Title"),
+        // sending "Name" to getRecordWithFields causes INVALID_FIELD at the DB layer (W-22253765).
+        // We stay permissive for mixed cases (some have Name, some don't) — those are handled
+        // server-side once W-22253765's companion fix lands in QueryValidatorImpl.
+        const anyHaveName = referenceToInfos.some((ref) => ref.nameFields.includes(FIELD_NAME$1));
+        return anyHaveName ? FIELD_NAME$1 : undefined;
     }
     const firstReferenceNameFields = referenceToInfos[0].nameFields;
     if (firstReferenceNameFields.length < 1) {
@@ -13010,8 +12975,11 @@ function getQualifiedFieldApiNamesFromLayout$1(layout, objectInfo) {
                             // By default, include the "Id" field on spanning records that are on the layout.
                             qualifiedFieldNames.push(`${objectInfo.apiName}.${relationshipFieldApiName}.${FIELD_ID$1}`);
                             const nameField = getNameField$1(objectInfo, apiName);
-                            // W-15692973: Name field of referenced entites are moved to optionalFields since the Name field may not exist for few entites.
-                            qualifiedOptionalFieldNames.push(`${objectInfo.apiName}.${relationshipFieldApiName}.${nameField}`);
+                            // W-15692973: Name field of referenced entities are moved to optionalFields since the Name field may not exist for few entities.
+                            // W-22253765: For polymorphic FKs where not all entities have "Name", nameField is undefined — skip the optional field entirely.
+                            if (nameField !== undefined) {
+                                qualifiedOptionalFieldNames.push(`${objectInfo.apiName}.${relationshipFieldApiName}.${nameField}`);
+                            }
                         }
                         qualifiedFieldNames.push(`${objectInfo.apiName}.${component.apiName}`);
                     }
@@ -13045,8 +13013,11 @@ function getMissingRecordLookupFields$1(record, objectInfo) {
         // Include the Id field. Ex: Opportunity.Account.Id, Opportunity.relation1__r.Id
         const idFieldName = `${apiName}.${relationshipName}.Id`;
         lookupFields[idFieldName] = true;
-        const nameField = `${apiName}.${relationshipName}.${getNameField$1(objectInfo, fieldName)}`;
-        lookupFields[nameField] = true;
+        const resolvedNameField = getNameField$1(objectInfo, fieldName);
+        // W-22253765: skip the name field for polymorphic FKs where not all entities have "Name"
+        if (resolvedNameField !== undefined) {
+            lookupFields[`${apiName}.${relationshipName}.${resolvedNameField}`] = true;
+        }
     }
     return keys$9(lookupFields);
 }
@@ -13906,7 +13877,6 @@ const notifyChangeFactory = (luvio) => {
                 const node = luvio.wrapNormalizedGraphNode(record, key);
                 const optionalFields = getTrackedFields$1(key, node, {
                     maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnNotifyChange(),
-                    onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
                 });
                 const refreshRequest = createResourceRequestFromRepresentation(record, optionalFields);
                 const existingWeakEtag = record.weakEtag;
@@ -16495,7 +16465,6 @@ function buildNetworkSnapshot$V(luvio, config, options) {
     const key = keyBuilder$1w$2(luvio, config);
     const trackedFieldsConfig = {
         maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-        onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly()
     };
     const optionalFieldsTrie = convertFieldsToTrie$1(getTrackedFields$1(key, luvio.getNode(key), trackedFieldsConfig, config.optionalFields));
     const fieldsTrie = BLANK_RECORD_FIELDS_TRIE$1;
@@ -30539,7 +30508,6 @@ const buildNetworkSnapshot$6$1 = (luvio, context, config, options) => {
                 ...resourceRequest.queryParams,
                 optionalFields: getTrackedFields$1(templateRecordKey, luvio.getNode(templateRecordKey), {
                     maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-                    onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
                 }, config.optionalFields),
             },
         });
@@ -31074,7 +31042,6 @@ function prepareRequest$8(luvio, context, config) {
             ...resourceRequest.queryParams,
             optionalFields: getTrackedFields$1(recordTemplateKey, luvio.getNode(recordTemplateKey), {
                 maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-                onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
             }, config.optionalFields),
         },
     });
@@ -31094,7 +31061,6 @@ function onFetchResponseSuccess$O(luvio, context, config, request, response, res
     });
     const allTrackedFields = getTrackedFields$1(templateRecordKey, luvio.getNode(templateRecordKey), {
         maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-        onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
     }, optionalFields);
     const allTrackedFieldsTrie = convertFieldsToTrie$1(allTrackedFields, true);
     const ingest = createFieldsIngestSuccess$4({
@@ -32550,7 +32516,7 @@ withDefaultLuvio((luvio) => {
     throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
     throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
 });
-// version: 1.433.0-db129b48d2
+// version: 1.435.0-615ebb9bbd
 
 var allowUpdatesForNonCachedRecords = {
     isOpen: function (e) {
@@ -44200,7 +44166,7 @@ const { create: create$7, freeze: freeze$4, keys: keys$8, entries: entries$5 } =
 const { hasOwnProperty: hasOwnProperty$3 } = Object.prototype;
 const { isArray: isArray$7 } = Array;
 const { stringify: stringify$9, parse: parse$9 } = JSON;
-let Ok$4 = class Ok {
+let Ok$3 = class Ok {
   constructor(value) {
     this.value = value;
   }
@@ -44211,7 +44177,7 @@ let Ok$4 = class Ok {
     return !this.isOk();
   }
 };
-let Err$4 = class Err {
+let Err$3 = class Err {
   constructor(error) {
     this.error = error;
   }
@@ -44222,8 +44188,8 @@ let Err$4 = class Err {
     return !this.isOk();
   }
 };
-const ok$4 = (value) => new Ok$4(value);
-const err$4 = (err2) => new Err$4(err2);
+const ok$3 = (value) => new Ok$3(value);
+const err$3 = (err2) => new Err$3(err2);
 function resolvedPromiseLike$4(result) {
   if (isPromiseLike$4(result)) {
     return result.then((nextResult) => nextResult);
@@ -44366,6 +44332,15 @@ function satisfies(provided, requested) {
   const requestedN = requested.split(".").map((s) => parseInt(s));
   return providedN[0] === requestedN[0] && providedN[1] >= requestedN[1];
 }
+function isUserVisibleError$3(error) {
+  return error instanceof Error && "type" in error && error.type === "user-visible";
+}
+function logError$2(error) {
+  if (isUserVisibleError$3(error)) {
+    return;
+  }
+  console.error("OneStore Command threw an error that we did not expect", error);
+}
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -44465,20 +44440,20 @@ class IdentifiableTypeRepository {
     const existingNormalizedData = (_a = cache.get(key)) == null ? void 0 : _a.value;
     const normalized = this.normalizeData(cache, { ...input, existingNormalizedData });
     if (normalized.isErr()) {
-      return err$4(normalized.error);
+      return err$3(normalized.error);
     }
     cache.set(key, {
       value: normalized.value,
       metadata: this.cacheMetadata
     });
-    return ok$4({
+    return ok$3({
       type: "link",
       linkedKey: key
     });
   }
   validateEntry(entry) {
     if (!isCacheEntryForType(entry, this)) {
-      return err$4([
+      return err$3([
         {
           type: "incorrectType",
           expectedType: this.typeName,
@@ -44486,7 +44461,7 @@ class IdentifiableTypeRepository {
         }
       ]);
     }
-    return ok$4(void 0);
+    return ok$3(void 0);
   }
   query(cache, query) {
     return this.read(cache, {
@@ -44504,12 +44479,12 @@ class IdentifiableTypeRepository {
     if (cacheEntry) {
       const validationResult = this.validateEntry(cacheEntry);
       if (validationResult.isErr()) {
-        return err$4([...validationResult.error]);
+        return err$3([...validationResult.error]);
       }
       const normalizedData = cacheEntry.value;
       return this.denormalizeData(cache, { ...input, normalizedData });
     }
-    return err$4([this.buildMissingDataError()]);
+    return err$3([this.buildMissingDataError()]);
   }
   equals(x, y) {
     return deepEquals$2(x, y);
@@ -44532,9 +44507,443 @@ function extractReadWriteData(result, errorCollector) {
 }
 function buildReadWriteResult(data, errors) {
   if (errors.length > 0) {
-    return err$4(errors);
+    return err$3(errors);
+  }
+  return ok$3(data);
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+let JsonSchemaViolationError$1 = class JsonSchemaViolationError extends Error {
+  constructor(message, validationErrors) {
+    super(message);
+    this.validationErrors = [];
+    this.validationErrors = validationErrors || [];
+  }
+};
+let MinItemsViolationError$1 = class MinItemsViolationError extends JsonSchemaViolationError$1 {
+};
+let MaxItemsViolationError$1 = class MaxItemsViolationError extends JsonSchemaViolationError$1 {
+};
+let IncorrectTypeError$1 = class IncorrectTypeError extends JsonSchemaViolationError$1 {
+};
+let AdditionalPropertiesError$1 = class AdditionalPropertiesError extends JsonSchemaViolationError$1 {
+};
+let MissingRequiredPropertyError$1 = class MissingRequiredPropertyError extends JsonSchemaViolationError$1 {
+};
+let InvalidRefError$1 = class InvalidRefError extends JsonSchemaViolationError$1 {
+};
+let JsonSchemaErrorCollector$1 = class JsonSchemaErrorCollector {
+  constructor() {
+    this.errors = [];
+  }
+  add(error) {
+    this.errors.push(error);
+  }
+  append(response) {
+    if (response.isErr()) {
+      this.errors.push(...response.error);
+    }
+  }
+  hasErrors() {
+    return this.errors.length > 0;
+  }
+  prepend(error) {
+    this.errors.unshift(error);
+  }
+  toValidationResponse() {
+    return !this.hasErrors() ? ok$3(true) : err$3(this.errors);
+  }
+};
+function createThrowableError$1(errors) {
+  if (errors[0] instanceof MinItemsViolationError$1) {
+    return new MinItemsViolationError$1(errors[0].message, errors);
+  }
+  if (errors[0] instanceof MaxItemsViolationError$1) {
+    return new MaxItemsViolationError$1(errors[0].message, errors);
+  }
+  if (errors[0] instanceof IncorrectTypeError$1) {
+    return new IncorrectTypeError$1(errors[0].message, errors);
+  }
+  if (errors[0] instanceof AdditionalPropertiesError$1) {
+    return new AdditionalPropertiesError$1(errors[0].message, errors);
+  }
+  if (errors[0] instanceof MissingRequiredPropertyError$1) {
+    return new MissingRequiredPropertyError$1(errors[0].message, errors);
+  }
+  if (errors[0] instanceof InvalidRefError$1) {
+    return new InvalidRefError$1(errors[0].message, errors);
+  }
+  return new JsonSchemaViolationError$1(errors[0].message, errors);
+}
+function assertIsValid$1(data, schema) {
+  const validationResponse = validateJsonSchema$1(data, schema);
+  if (validationResponse.isErr()) {
+    throw createThrowableError$1(validationResponse.error);
+  }
+}
+function incorrectTypeError$1(expected, actual, path) {
+  return new IncorrectTypeError$1(
+    `Expected type ${expected} at path '${path}', found type ${actual}.`
+  );
+}
+function validSchemaResponse$1() {
+  return ok$3(true);
+}
+function invalidSchemaResponseWithError$1(error) {
+  return err$3([error]);
+}
+function validateJsonSchema$1(data, schema, path = "$", document = schema) {
+  return validateJsonSchemaInternal$1(data, schema, path, document, /* @__PURE__ */ new Map());
+}
+function validateJsonSchemaInternal$1(data, schema, path, document, visited) {
+  if (schema === true) return validSchemaResponse$1();
+  if (schema === false)
+    return invalidSchemaResponseWithError$1(
+      new JsonSchemaViolationError$1(`Data at ${path} has schema 'false'`)
+    );
+  const dataType = data === null ? "null" : Array.isArray(data) ? "array" : typeof data;
+  const errorCollector = new JsonSchemaErrorCollector$1();
+  if ("anyOf" in schema) {
+    errorCollector.append(validateAnyOf$1(data, schema, path, document, visited));
+  } else if ("oneOf" in schema) {
+    errorCollector.append(validateOneOf$1(data, schema, path, document, visited));
+  } else if ("allOf" in schema) {
+    errorCollector.append(validateAllOf$1(data, schema, path, document, visited));
+  } else if ("not" in schema) {
+    errorCollector.append(validateNot$1(data, schema, path, document, visited));
+  } else if ("$ref" in schema) {
+    errorCollector.append(validateRef$1(data, schema, path, document, visited));
+  } else if ("type" in schema) {
+    if (schema.type === "object") {
+      if (dataType !== "object") {
+        errorCollector.add(incorrectTypeError$1("object", dataType, path));
+      } else {
+        errorCollector.append(
+          validateObject$1(data, schema, path, document, visited)
+        );
+      }
+    } else if (schema.type === "array") {
+      if (dataType !== "array") {
+        errorCollector.add(incorrectTypeError$1("array", dataType, path));
+      } else {
+        errorCollector.append(
+          validateArray$1(data, schema, path, document, visited)
+        );
+      }
+    } else {
+      errorCollector.append(
+        validateScalar$1(data, schema, path)
+      );
+    }
+  }
+  if (schema.enum) {
+    errorCollector.append(validateEnum$1(data, schema.enum, path));
+  }
+  if (schema.const) {
+    errorCollector.append(validateConst$1(data, schema.const, path));
+  }
+  return errorCollector.toValidationResponse();
+}
+function validateAnyOf$1(data, schema, path, document, visited) {
+  let isValid = false;
+  const errorCollector = new JsonSchemaErrorCollector$1();
+  for (let i = 0, { length } = schema.anyOf; i < length; i++) {
+    const element = schema.anyOf[i];
+    const validationResponse = validateJsonSchemaInternal$1(
+      data,
+      element,
+      `${path}.anyOf[${i}]`,
+      document,
+      visited
+    );
+    if (validationResponse.isOk()) {
+      isValid = true;
+      break;
+    } else {
+      errorCollector.append(validationResponse);
+    }
+  }
+  if (!isValid) {
+    errorCollector.prepend(
+      new JsonSchemaViolationError$1(`Data at ${path} did not match any subschema in anyOf.`)
+    );
+    return errorCollector.toValidationResponse();
+  }
+  return validSchemaResponse$1();
+}
+function validateOneOf$1(data, schema, path, document, visited) {
+  if (schema.discriminator !== void 0) {
+    return validateDiscriminatedOneOf$1(data, schema.discriminator, path, document, visited);
+  }
+  let validSubShemaPaths = [];
+  const errorCollector = new JsonSchemaErrorCollector$1();
+  for (let i = 0, { length } = schema.oneOf; i < length; i++) {
+    const element = schema.oneOf[i];
+    const oneOfPath = `${path}.oneOf[${i}]`;
+    const validationResponse = validateJsonSchemaInternal$1(
+      data,
+      element,
+      oneOfPath,
+      document,
+      visited
+    );
+    if (validationResponse.isOk()) {
+      validSubShemaPaths.push(oneOfPath);
+    } else {
+      errorCollector.append(validationResponse);
+    }
+  }
+  if (validSubShemaPaths.length === 0) {
+    errorCollector.prepend(
+      new JsonSchemaViolationError$1(`Data at ${path} did not match any subschema in oneOf.`)
+    );
+    return errorCollector.toValidationResponse();
+  } else if (validSubShemaPaths.length > 1) {
+    errorCollector.prepend(
+      new JsonSchemaViolationError$1(
+        `Data at ${path} matched multiple subschemas: [${validSubShemaPaths.join(", ")}].`
+      )
+    );
+    return errorCollector.toValidationResponse();
+  }
+  return validSchemaResponse$1();
+}
+function validateDiscriminatedOneOf$1(data, discriminator, path, document, visited) {
+  if (data === null || typeof data !== "object" || Array.isArray(data)) {
+    return invalidSchemaResponseWithError$1(incorrectTypeError$1("object", typeof data, path));
   }
-  return ok$4(data);
+  const { propertyName, mapping } = discriminator;
+  const discriminatorValue = data[propertyName];
+  if (discriminatorValue === void 0) {
+    return invalidSchemaResponseWithError$1(
+      new MissingRequiredPropertyError$1(
+        `Object at path '${path}' is missing required discriminator property '${propertyName}'.`
+      )
+    );
+  }
+  if (typeof discriminatorValue !== "string") {
+    return invalidSchemaResponseWithError$1(
+      incorrectTypeError$1("string", typeof discriminatorValue, `${path}.${propertyName}`)
+    );
+  }
+  const targetRef = mapping[discriminatorValue];
+  if (targetRef === void 0) {
+    return invalidSchemaResponseWithError$1(
+      new JsonSchemaViolationError$1(
+        `Discriminator value '${discriminatorValue}' at '${path}.${propertyName}' is not in the mapping. Expected one of: [${Object.keys(mapping).join(", ")}].`
+      )
+    );
+  }
+  return validateJsonSchemaInternal$1(data, { $ref: targetRef }, path, document, visited);
+}
+function validateAllOf$1(data, schema, path, document, visited) {
+  let isValid = true;
+  const errorCollector = new JsonSchemaErrorCollector$1();
+  for (let i = 0, { length } = schema.allOf; i < length; i++) {
+    const element = schema.allOf[i];
+    const validationResponse = validateJsonSchemaInternal$1(
+      data,
+      element,
+      `${path}.allOf[${i}]`,
+      document,
+      visited
+    );
+    if (!validationResponse.isOk()) {
+      errorCollector.append(validationResponse);
+      isValid = false;
+    }
+  }
+  if (!isValid) {
+    errorCollector.prepend(
+      new JsonSchemaViolationError$1(`Data at ${path} did not match some subschemas in allOf.`)
+    );
+  }
+  return errorCollector.toValidationResponse();
+}
+function validateNot$1(data, schema, path, document, visited) {
+  const validationResponse = validateJsonSchemaInternal$1(
+    data,
+    schema.not,
+    path,
+    document,
+    visited
+  );
+  if (validationResponse.isOk()) {
+    return invalidSchemaResponseWithError$1(
+      new JsonSchemaViolationError$1(
+        `Data at ${path} validated against the schema of a not clause.`
+      )
+    );
+  }
+  return validSchemaResponse$1();
+}
+function validateObject$1(data, schema, path, document, visited) {
+  const schemaKeys = Object.keys(schema.properties);
+  const requiredKeys = new Set(schema.required);
+  const schemaKeySet = new Set(schemaKeys);
+  const errorCollector = new JsonSchemaErrorCollector$1();
+  Object.keys(data).forEach((key) => {
+    if (!schemaKeySet.has(key)) {
+      errorCollector.append(
+        validateJsonSchemaInternal$1(
+          data[key],
+          schema.additionalProperties,
+          `${path}.additionalProperties[${key}]`,
+          document,
+          visited
+        )
+      );
+    }
+  });
+  for (let i = 0, length = schemaKeys.length; i < length; i++) {
+    const key = schemaKeys[i];
+    const keyInData = key in data && data[key] !== void 0;
+    if (requiredKeys.has(key) && !keyInData) {
+      errorCollector.add(
+        new MissingRequiredPropertyError$1(
+          `Object at path '${path}' is missing required property '${key}'.`
+        )
+      );
+    }
+    if (keyInData) {
+      errorCollector.append(
+        validateJsonSchemaInternal$1(
+          data[key],
+          schema.properties[key],
+          `${path}.${key}`,
+          document,
+          visited
+        )
+      );
+    }
+  }
+  return errorCollector.toValidationResponse();
+}
+function validateArray$1(data, schema, path, document, visited) {
+  if (schema.minItems !== void 0 && data.length < schema.minItems) {
+    return invalidSchemaResponseWithError$1(
+      new MinItemsViolationError$1(
+        `Array at path '${path}' fails minItems constraint. Has ${data.length} items, needs at least ${schema.minItems}.`
+      )
+    );
+  }
+  if (schema.maxItems !== void 0 && data.length > schema.maxItems) {
+    return invalidSchemaResponseWithError$1(
+      new MaxItemsViolationError$1(
+        `Array at path '${path}' fails maxItems constraint. Has ${data.length} items, needs at most ${schema.maxItems}.`
+      )
+    );
+  }
+  const errorCollector = new JsonSchemaErrorCollector$1();
+  data.forEach(
+    (element, index) => errorCollector.append(
+      validateJsonSchemaInternal$1(
+        element,
+        schema.items,
+        `${path}[${index}]`,
+        document,
+        visited
+      )
+    )
+  );
+  return errorCollector.toValidationResponse();
+}
+function validateScalar$1(data, schema, path) {
+  const schemaDataType = schema.type;
+  const dataType = typeof data;
+  if (schemaDataType === "integer") {
+    if (dataType !== "number" || !Number.isInteger(data)) {
+      return invalidSchemaResponseWithError$1(incorrectTypeError$1("integer", dataType, path));
+    }
+  } else if (schemaDataType === "number") {
+    if (dataType !== "number") {
+      return invalidSchemaResponseWithError$1(incorrectTypeError$1("number", dataType, path));
+    }
+  } else if (schemaDataType === "string") {
+    if (dataType !== "string") {
+      return invalidSchemaResponseWithError$1(incorrectTypeError$1("string", dataType, path));
+    }
+  } else if (schemaDataType === "boolean") {
+    if (dataType !== "boolean") {
+      return invalidSchemaResponseWithError$1(incorrectTypeError$1("boolean", dataType, path));
+    }
+  } else if (schemaDataType === "null") {
+    if (data !== null) {
+      return invalidSchemaResponseWithError$1(incorrectTypeError$1("null", dataType, path));
+    }
+  } else {
+    return invalidSchemaResponseWithError$1(
+      new IncorrectTypeError$1(`Unknown schema data type: ${schemaDataType}.`)
+    );
+  }
+  return validSchemaResponse$1();
+}
+function validateRef$1(data, schema, path, document, visited) {
+  if (!schema.$ref.startsWith("#")) {
+    return invalidSchemaResponseWithError$1(
+      new InvalidRefError$1(
+        `$ref values that do not refer to the current document are unsupported (must start with '#')`
+      )
+    );
+  }
+  let refsForData = visited.get(data);
+  if (refsForData !== void 0 && refsForData.has(schema.$ref)) {
+    return validSchemaResponse$1();
+  }
+  if (refsForData === void 0) {
+    refsForData = /* @__PURE__ */ new Set();
+    visited.set(data, refsForData);
+  }
+  refsForData.add(schema.$ref);
+  try {
+    const schemaToValidate = findSchemaAtPath$1(document, schema.$ref);
+    return validateJsonSchemaInternal$1(data, schemaToValidate, path, document, visited);
+  } catch (e) {
+    return invalidSchemaResponseWithError$1(e);
+  } finally {
+    refsForData.delete(schema.$ref);
+    if (refsForData.size === 0) visited.delete(data);
+  }
+}
+function validateEnum$1(data, enumValue, path) {
+  if (!enumValue.some((value) => deepEquals$2(value, data))) {
+    return invalidSchemaResponseWithError$1(
+      new JsonSchemaViolationError$1(
+        `Data at ${path} did not match any values in enum. Expected value in: [${enumValue.map((value) => stringify$9(value)).join()}]`
+      )
+    );
+  }
+  return validSchemaResponse$1();
+}
+function validateConst$1(data, constValue, path) {
+  if (!deepEquals$2(constValue, data)) {
+    return invalidSchemaResponseWithError$1(
+      new JsonSchemaViolationError$1(
+        `Data at ${path} did not match const. Expected: ${stringify$9(constValue)}`
+      )
+    );
+  }
+  return validSchemaResponse$1();
+}
+function findSchemaAtPath$1(document, ref) {
+  if (ref === "#") return document;
+  const keys = ref.replace(/^#\//, "").split("/");
+  let current = document;
+  let path = "#";
+  for (const key of keys) {
+    path = `${path}/${key}`;
+    if (current[key] === void 0) {
+      throw new InvalidRefError$1(
+        `Invalid $ref value '${ref}'. Cannot find target schema at '${path}'`
+      );
+    }
+    current = current[key];
+  }
+  return current;
 }
 
 /*!
@@ -45381,35 +45790,6 @@ const astResolver = function(astReference) {
   }
   return referenceMap.get(astReference);
 };
-/*!
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-let Ok$3 = class Ok {
-  constructor(value) {
-    this.value = value;
-  }
-  isOk() {
-    return true;
-  }
-  isErr() {
-    return !this.isOk();
-  }
-};
-let Err$3 = class Err {
-  constructor(error) {
-    this.error = error;
-  }
-  isOk() {
-    return false;
-  }
-  isErr() {
-    return !this.isOk();
-  }
-};
-const ok$3 = (value) => new Ok$3(value);
-const err$3 = (err2) => new Err$3(err2);
 function findExecutableOperation$2(document, operationName) {
   const operations = document.definitions.filter(
     (def) => def.kind === Kind$1.OPERATION_DEFINITION
@@ -45460,6 +45840,14 @@ function resolveAndValidateGraphQLConfig(config, options) {
     query: result.value
   });
 }
+function toGraphQLErrorResponse(error) {
+  logError$2(error);
+  const message = error instanceof JsonSchemaViolationError$1 ? `Invalid GraphQL config: ${error.message}` : "Internal error in GraphQL adapter occurred";
+  return {
+    data: void 0,
+    errors: [{ message, locations: [] }]
+  };
+}
 function resolveAndValidateGraphQLDocument(query, operationName, options) {
   const resolved = resolveAst(query);
   if (resolved === void 0) {
@@ -45725,7 +46113,11 @@ function buildAndDispatchGetRecordAggregateUi(recordId, req, params) {
         queryParams: {},
         headers: {},
     };
-    return dispatchSplitRecordAggregateUiAction(recordId, networkAdapter, aggregateUiResourceRequest, resourceRequestContext);
+    // Re-enter the composed adapter (when registered) so routing and interceptors
+    // apply to the synthesized aggregate-ui sub-request. Fall back to the base
+    // adapter when unregistered (e.g. in lds-network-adapter unit tests).
+    const subRequestAdapter = networkAdapter;
+    return dispatchSplitRecordAggregateUiAction(recordId, subRequestAdapter, aggregateUiResourceRequest, resourceRequestContext);
 }
 const getRecordDispatcher = (req) => {
     const { resourceRequest, networkAdapter, resourceRequestContext } = req;
@@ -45781,7 +46173,6 @@ function matchRecordsHandlers(path, resourceRequest) {
     }
     return null;
 }
-
 const defaultDispatcher = (req) => {
     const { networkAdapter, resourceRequest, resourceRequestContext } = req;
     return networkAdapter(resourceRequest, resourceRequestContext);
@@ -51198,7 +51589,6 @@ function prepareRequest$5(luvio, config) {
     const key = keyBuilder$1M(luvio, createResourceParams$g(config));
     const allTrackedFields = getTrackedFields(key, luvio.getNode(key), {
         maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-        onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
     }, config.optionalFields);
     const optionalFields = fields === undefined ? allTrackedFields : difference(allTrackedFields, fields);
     const resourceParams = createResourceParams$g({
@@ -51325,7 +51715,6 @@ function ingestSuccessChildResourceParams$2(luvio, childResourceParamsArray, chi
             };
             const childTrackedFields = getTrackedFields(childKey, luvio.getNode(childKey), {
                 maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-                onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
             }, childResourceParams.queryParams.optionalFields);
             const childSnapshot = ingestSuccess$8(luvio, {
                 recordId: childResourceParams.urlParams.recordId,
@@ -56295,7 +56684,6 @@ function buildNetworkSnapshot$c(luvio, config, options) {
     const key = keyBuilder$1w$1(luvio, config);
     const trackedFieldsConfig = {
         maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-        onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
     };
     const optionalFieldsTrie = convertFieldsToTrie(getTrackedFields(key, luvio.getNode(key), trackedFieldsConfig, config.optionalFields));
     const fieldsTrie = BLANK_RECORD_FIELDS_TRIE;
@@ -60167,7 +60555,6 @@ const buildNetworkSnapshot$3 = (luvio, context, config, options) => {
                 ...resourceRequest.queryParams,
                 optionalFields: getTrackedFields(templateRecordKey, luvio.getNode(templateRecordKey), {
                     maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-                    onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
                 }, config.optionalFields),
             },
         });
@@ -60719,7 +61106,6 @@ function prepareRequest(luvio, context, config) {
             ...resourceRequest.queryParams,
             optionalFields: getTrackedFields(recordTemplateKey, luvio.getNode(recordTemplateKey), {
                 maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-                onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
             }, config.optionalFields),
         },
     });
@@ -60739,7 +61125,6 @@ function onFetchResponseSuccess$2(luvio, context, config, request, response, res
     });
     const allTrackedFields = getTrackedFields(templateRecordKey, luvio.getNode(templateRecordKey), {
         maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-        onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
     }, optionalFields);
     const allTrackedFieldsTrie = convertFieldsToTrie(allTrackedFields, true);
     const ingest = createFieldsIngestSuccess({
@@ -80503,6 +80888,7 @@ class AbstractQuickActionHandler extends AbstractResourceRequestActionHandler {
     }
     async buildPendingAction(request, queue) {
         this.resolveResourceRequestBody(request.body);
+        // eslint-disable-next-line no-return-await
         return await super.buildPendingAction(request, queue);
     }
     resolveResourceRequestBody(body) {
@@ -80935,8 +81321,6 @@ function isCreateContentDocumentAndVersionDraftAdapterEvent(customEvent) {
     return customEvent.namespace === CONTENT_DOCUMENT_AND_VERSION_NAMESPACE;
 }
 
-// so eslint doesn't complain about nimbus
-/* global __nimbus */
 function chunkToBase64(chunk) {
     const bytes = new Uint8Array(chunk);
     const CHUNK_SIZE = 64 * 1024; // 64kb, any bigger and fromCharCode() can error out with an overflow.
@@ -87016,6 +87400,7 @@ function isPolymorphicFieldPath(path, pathToObjectApiNamesMap, objectInfos) {
     const parentObjectInfo = objectInfos[parentObjectApiNames[0]];
     // this should not be undefined, but lets catch it if we do end up in that state.
     if (parentObjectInfo === undefined) {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
         throw new Error(`ObjectInfo is missing for ${parentObjectApiNames[0]} for ${parentApiPath}`);
     }
     const relationshipField = referenceIdFieldForRelationship(lastSegment);
@@ -88388,6 +88773,7 @@ function checkForEmptyData(gqlResult) {
     }
     const query = data.uiapi.query;
     // Check all entity types in the query for edges - using for...in to avoid array allocation
+    // eslint-disable-next-line guard-for-in
     for (const entityType in query) {
         const entity = query[entityType];
         if (entity && entity.edges && isArray$3$1(entity.edges) && entity.edges.length > 0) {
@@ -90309,7 +90695,9 @@ class NimbusSqliteStore {
             }
             instrumentation$2$1.trackValue(GRAPHQL_QUERY_ROOT_METRIC_NAME, row[1].length);
         }
-        catch { }
+        catch {
+            // intentionally do nothing
+        }
     }
 }
 
@@ -91018,6 +91406,7 @@ class PrimingSession extends EventEmitter {
         const userData = {
             ...stats,
         };
+        // eslint-disable-next-line guard-for-in
         for (const error in errors) {
             activity.error(error);
         }
@@ -91198,6 +91587,7 @@ class PrimingSession extends EventEmitter {
             let limitedResult = this.applyRetryLimits(result.additionalWork);
             this.enqueue(limitedResult.additionalWork);
             if (limitedResult.recordsNeedingRefetch.size > 0) {
+                // eslint-disable-next-line guard-for-in
                 for (const key in keys$3(limitedResult.recordsNeedingRefetch)) {
                     const value = limitedResult.recordsNeedingRefetch.get(key);
                     if (result.recordsNeedingRefetch.has(key)) {
@@ -93463,6 +93853,7 @@ class DurableRecordStore {
     async exists(key) {
         const result = await this.durableStore.query('SELECT EXISTS(SELECT 1 FROM lds_data WHERE key = ?)', [key]);
         const exists = result.rows[0][0];
+        // eslint-disable-next-line eqeqeq
         return exists == true;
     }
     async getRecord(key) {
@@ -93677,7 +94068,7 @@ var CounterResult;
     CounterResult["Error"] = "Error";
 })(CounterResult || (CounterResult = {}));
 function incrementCounter(name, result) {
-    instrumentation$4.incrementCounter('SFSSideEffect', 1, result == CounterResult.Error, {
+    instrumentation$4.incrementCounter('SFSSideEffect', 1, result === CounterResult.Error, {
         Name: name,
         Result: result,
     });
@@ -96249,7 +96640,7 @@ function buildServiceDescriptor$b(luvio) {
         },
     };
 }
-// version: 1.433.0-db129b48d2
+// version: 1.435.0-5818ce3c48
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -96275,7 +96666,7 @@ function buildServiceDescriptor$a(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.433.0-db129b48d2
+// version: 1.435.0-5818ce3c48
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -96680,26 +97071,26 @@ function buildServiceDescriptor$8() {
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-let JsonSchemaViolationError$1 = class JsonSchemaViolationError extends Error {
+class JsonSchemaViolationError extends Error {
   constructor(message, validationErrors) {
     super(message);
     this.validationErrors = [];
     this.validationErrors = validationErrors || [];
   }
-};
-let MinItemsViolationError$1 = class MinItemsViolationError extends JsonSchemaViolationError$1 {
-};
-let MaxItemsViolationError$1 = class MaxItemsViolationError extends JsonSchemaViolationError$1 {
-};
-let IncorrectTypeError$1 = class IncorrectTypeError extends JsonSchemaViolationError$1 {
-};
-let AdditionalPropertiesError$1 = class AdditionalPropertiesError extends JsonSchemaViolationError$1 {
-};
-let MissingRequiredPropertyError$1 = class MissingRequiredPropertyError extends JsonSchemaViolationError$1 {
-};
-let InvalidRefError$1 = class InvalidRefError extends JsonSchemaViolationError$1 {
-};
-let JsonSchemaErrorCollector$1 = class JsonSchemaErrorCollector {
+}
+class MinItemsViolationError extends JsonSchemaViolationError {
+}
+class MaxItemsViolationError extends JsonSchemaViolationError {
+}
+class IncorrectTypeError extends JsonSchemaViolationError {
+}
+class AdditionalPropertiesError extends JsonSchemaViolationError {
+}
+class MissingRequiredPropertyError extends JsonSchemaViolationError {
+}
+class InvalidRefError extends JsonSchemaViolationError {
+}
+class JsonSchemaErrorCollector {
   constructor() {
     this.errors = [];
   }
@@ -96720,104 +97111,108 @@ let JsonSchemaErrorCollector$1 = class JsonSchemaErrorCollector {
   toValidationResponse() {
     return !this.hasErrors() ? ok$1(true) : err$1(this.errors);
   }
-};
-function createThrowableError$1(errors) {
-  if (errors[0] instanceof MinItemsViolationError$1) {
-    return new MinItemsViolationError$1(errors[0].message, errors);
+}
+function createThrowableError(errors) {
+  if (errors[0] instanceof MinItemsViolationError) {
+    return new MinItemsViolationError(errors[0].message, errors);
   }
-  if (errors[0] instanceof MaxItemsViolationError$1) {
-    return new MaxItemsViolationError$1(errors[0].message, errors);
+  if (errors[0] instanceof MaxItemsViolationError) {
+    return new MaxItemsViolationError(errors[0].message, errors);
   }
-  if (errors[0] instanceof IncorrectTypeError$1) {
-    return new IncorrectTypeError$1(errors[0].message, errors);
+  if (errors[0] instanceof IncorrectTypeError) {
+    return new IncorrectTypeError(errors[0].message, errors);
   }
-  if (errors[0] instanceof AdditionalPropertiesError$1) {
-    return new AdditionalPropertiesError$1(errors[0].message, errors);
+  if (errors[0] instanceof AdditionalPropertiesError) {
+    return new AdditionalPropertiesError(errors[0].message, errors);
   }
-  if (errors[0] instanceof MissingRequiredPropertyError$1) {
-    return new MissingRequiredPropertyError$1(errors[0].message, errors);
+  if (errors[0] instanceof MissingRequiredPropertyError) {
+    return new MissingRequiredPropertyError(errors[0].message, errors);
   }
-  if (errors[0] instanceof InvalidRefError$1) {
-    return new InvalidRefError$1(errors[0].message, errors);
+  if (errors[0] instanceof InvalidRefError) {
+    return new InvalidRefError(errors[0].message, errors);
   }
-  return new JsonSchemaViolationError$1(errors[0].message, errors);
+  return new JsonSchemaViolationError(errors[0].message, errors);
 }
-function assertIsValid$1(data, schema) {
-  const validationResponse = validateJsonSchema$1(data, schema);
+function assertIsValid(data, schema) {
+  const validationResponse = validateJsonSchema(data, schema);
   if (validationResponse.isErr()) {
-    throw createThrowableError$1(validationResponse.error);
+    throw createThrowableError(validationResponse.error);
   }
 }
-function incorrectTypeError$1(expected, actual, path) {
-  return new IncorrectTypeError$1(
+function incorrectTypeError(expected, actual, path) {
+  return new IncorrectTypeError(
     `Expected type ${expected} at path '${path}', found type ${actual}.`
   );
 }
-function validSchemaResponse$1() {
+function validSchemaResponse() {
   return ok$1(true);
 }
-function invalidSchemaResponseWithError$1(error) {
+function invalidSchemaResponseWithError(error) {
   return err$1([error]);
 }
-function validateJsonSchema$1(data, schema, path = "$", document = schema) {
-  if (schema === true) return validSchemaResponse$1();
+function validateJsonSchema(data, schema, path = "$", document = schema) {
+  return validateJsonSchemaInternal(data, schema, path, document, /* @__PURE__ */ new Map());
+}
+function validateJsonSchemaInternal(data, schema, path, document, visited) {
+  if (schema === true) return validSchemaResponse();
   if (schema === false)
-    return invalidSchemaResponseWithError$1(
-      new JsonSchemaViolationError$1(`Data at ${path} has schema 'false'`)
+    return invalidSchemaResponseWithError(
+      new JsonSchemaViolationError(`Data at ${path} has schema 'false'`)
     );
   const dataType = data === null ? "null" : Array.isArray(data) ? "array" : typeof data;
-  const errorCollector = new JsonSchemaErrorCollector$1();
+  const errorCollector = new JsonSchemaErrorCollector();
   if ("anyOf" in schema) {
-    errorCollector.append(validateAnyOf$1(data, schema, path, document));
+    errorCollector.append(validateAnyOf(data, schema, path, document, visited));
   } else if ("oneOf" in schema) {
-    errorCollector.append(validateOneOf$1(data, schema, path, document));
+    errorCollector.append(validateOneOf(data, schema, path, document, visited));
   } else if ("allOf" in schema) {
-    errorCollector.append(validateAllOf$1(data, schema, path, document));
+    errorCollector.append(validateAllOf(data, schema, path, document, visited));
   } else if ("not" in schema) {
-    errorCollector.append(validateNot$1(data, schema, path, document));
+    errorCollector.append(validateNot(data, schema, path, document, visited));
   } else if ("$ref" in schema) {
-    errorCollector.append(validateRef$1(data, schema, path, document));
+    errorCollector.append(validateRef(data, schema, path, document, visited));
   } else if ("type" in schema) {
     if (schema.type === "object") {
       if (dataType !== "object") {
-        errorCollector.add(incorrectTypeError$1("object", dataType, path));
+        errorCollector.add(incorrectTypeError("object", dataType, path));
       } else {
         errorCollector.append(
-          validateObject$1(data, schema, path, document)
+          validateObject(data, schema, path, document, visited)
         );
       }
     } else if (schema.type === "array") {
       if (dataType !== "array") {
-        errorCollector.add(incorrectTypeError$1("array", dataType, path));
+        errorCollector.add(incorrectTypeError("array", dataType, path));
       } else {
         errorCollector.append(
-          validateArray$1(data, schema, path, document)
+          validateArray(data, schema, path, document, visited)
         );
       }
     } else {
       errorCollector.append(
-        validateScalar$1(data, schema, path)
+        validateScalar(data, schema, path)
       );
     }
   }
   if (schema.enum) {
-    errorCollector.append(validateEnum$1(data, schema.enum, path));
+    errorCollector.append(validateEnum(data, schema.enum, path));
   }
   if (schema.const) {
-    errorCollector.append(validateConst$1(data, schema.const, path));
+    errorCollector.append(validateConst(data, schema.const, path));
   }
   return errorCollector.toValidationResponse();
 }
-function validateAnyOf$1(data, schema, path, document) {
+function validateAnyOf(data, schema, path, document, visited) {
   let isValid = false;
-  const errorCollector = new JsonSchemaErrorCollector$1();
+  const errorCollector = new JsonSchemaErrorCollector();
   for (let i = 0, { length } = schema.anyOf; i < length; i++) {
     const element = schema.anyOf[i];
-    const validationResponse = validateJsonSchema$1(
+    const validationResponse = validateJsonSchemaInternal(
       data,
       element,
       `${path}.anyOf[${i}]`,
-      document
+      document,
+      visited
     );
     if (validationResponse.isOk()) {
       isValid = true;
@@ -96828,19 +97223,28 @@ function validateAnyOf$1(data, schema, path, document) {
   }
   if (!isValid) {
     errorCollector.prepend(
-      new JsonSchemaViolationError$1(`Data at ${path} did not match any subschema in anyOf.`)
+      new JsonSchemaViolationError(`Data at ${path} did not match any subschema in anyOf.`)
     );
     return errorCollector.toValidationResponse();
   }
-  return validSchemaResponse$1();
+  return validSchemaResponse();
 }
-function validateOneOf$1(data, schema, path, document) {
+function validateOneOf(data, schema, path, document, visited) {
+  if (schema.discriminator !== void 0) {
+    return validateDiscriminatedOneOf(data, schema.discriminator, path, document, visited);
+  }
   let validSubShemaPaths = [];
-  const errorCollector = new JsonSchemaErrorCollector$1();
+  const errorCollector = new JsonSchemaErrorCollector();
   for (let i = 0, { length } = schema.oneOf; i < length; i++) {
     const element = schema.oneOf[i];
     const oneOfPath = `${path}.oneOf[${i}]`;
-    const validationResponse = validateJsonSchema$1(data, element, oneOfPath, document);
+    const validationResponse = validateJsonSchemaInternal(
+      data,
+      element,
+      oneOfPath,
+      document,
+      visited
+    );
     if (validationResponse.isOk()) {
       validSubShemaPaths.push(oneOfPath);
     } else {
@@ -96849,29 +97253,58 @@ function validateOneOf$1(data, schema, path, document) {
   }
   if (validSubShemaPaths.length === 0) {
     errorCollector.prepend(
-      new JsonSchemaViolationError$1(`Data at ${path} did not match any subschema in oneOf.`)
+      new JsonSchemaViolationError(`Data at ${path} did not match any subschema in oneOf.`)
     );
     return errorCollector.toValidationResponse();
   } else if (validSubShemaPaths.length > 1) {
     errorCollector.prepend(
-      new JsonSchemaViolationError$1(
+      new JsonSchemaViolationError(
         `Data at ${path} matched multiple subschemas: [${validSubShemaPaths.join(", ")}].`
       )
     );
     return errorCollector.toValidationResponse();
   }
-  return validSchemaResponse$1();
+  return validSchemaResponse();
+}
+function validateDiscriminatedOneOf(data, discriminator, path, document, visited) {
+  if (data === null || typeof data !== "object" || Array.isArray(data)) {
+    return invalidSchemaResponseWithError(incorrectTypeError("object", typeof data, path));
+  }
+  const { propertyName, mapping } = discriminator;
+  const discriminatorValue = data[propertyName];
+  if (discriminatorValue === void 0) {
+    return invalidSchemaResponseWithError(
+      new MissingRequiredPropertyError(
+        `Object at path '${path}' is missing required discriminator property '${propertyName}'.`
+      )
+    );
+  }
+  if (typeof discriminatorValue !== "string") {
+    return invalidSchemaResponseWithError(
+      incorrectTypeError("string", typeof discriminatorValue, `${path}.${propertyName}`)
+    );
+  }
+  const targetRef = mapping[discriminatorValue];
+  if (targetRef === void 0) {
+    return invalidSchemaResponseWithError(
+      new JsonSchemaViolationError(
+        `Discriminator value '${discriminatorValue}' at '${path}.${propertyName}' is not in the mapping. Expected one of: [${Object.keys(mapping).join(", ")}].`
+      )
+    );
+  }
+  return validateJsonSchemaInternal(data, { $ref: targetRef }, path, document, visited);
 }
-function validateAllOf$1(data, schema, path, document) {
+function validateAllOf(data, schema, path, document, visited) {
   let isValid = true;
-  const errorCollector = new JsonSchemaErrorCollector$1();
+  const errorCollector = new JsonSchemaErrorCollector();
   for (let i = 0, { length } = schema.allOf; i < length; i++) {
     const element = schema.allOf[i];
-    const validationResponse = validateJsonSchema$1(
+    const validationResponse = validateJsonSchemaInternal(
       data,
       element,
       `${path}.allOf[${i}]`,
-      document
+      document,
+      visited
     );
     if (!validationResponse.isOk()) {
       errorCollector.append(validationResponse);
@@ -96880,35 +97313,42 @@ function validateAllOf$1(data, schema, path, document) {
   }
   if (!isValid) {
     errorCollector.prepend(
-      new JsonSchemaViolationError$1(`Data at ${path} did not match some subschemas in allOf.`)
+      new JsonSchemaViolationError(`Data at ${path} did not match some subschemas in allOf.`)
     );
   }
   return errorCollector.toValidationResponse();
 }
-function validateNot$1(data, schema, path, document) {
-  const validationResponse = validateJsonSchema$1(data, schema.not, path, document);
+function validateNot(data, schema, path, document, visited) {
+  const validationResponse = validateJsonSchemaInternal(
+    data,
+    schema.not,
+    path,
+    document,
+    visited
+  );
   if (validationResponse.isOk()) {
-    return invalidSchemaResponseWithError$1(
-      new JsonSchemaViolationError$1(
+    return invalidSchemaResponseWithError(
+      new JsonSchemaViolationError(
         `Data at ${path} validated against the schema of a not clause.`
       )
     );
   }
-  return validSchemaResponse$1();
+  return validSchemaResponse();
 }
-function validateObject$1(data, schema, path, document) {
+function validateObject(data, schema, path, document, visited) {
   const schemaKeys = Object.keys(schema.properties);
   const requiredKeys = new Set(schema.required);
   const schemaKeySet = new Set(schemaKeys);
-  const errorCollector = new JsonSchemaErrorCollector$1();
+  const errorCollector = new JsonSchemaErrorCollector();
   Object.keys(data).forEach((key) => {
     if (!schemaKeySet.has(key)) {
       errorCollector.append(
-        validateJsonSchema$1(
+        validateJsonSchemaInternal(
           data[key],
           schema.additionalProperties,
           `${path}.additionalProperties[${key}]`,
-          document
+          document,
+          visited
         )
       );
     }
@@ -96918,113 +97358,132 @@ function validateObject$1(data, schema, path, document) {
     const keyInData = key in data && data[key] !== void 0;
     if (requiredKeys.has(key) && !keyInData) {
       errorCollector.add(
-        new MissingRequiredPropertyError$1(
+        new MissingRequiredPropertyError(
           `Object at path '${path}' is missing required property '${key}'.`
         )
       );
     }
     if (keyInData) {
       errorCollector.append(
-        validateJsonSchema$1(
+        validateJsonSchemaInternal(
           data[key],
           schema.properties[key],
           `${path}.${key}`,
-          document
+          document,
+          visited
         )
       );
     }
   }
   return errorCollector.toValidationResponse();
 }
-function validateArray$1(data, schema, path, document) {
+function validateArray(data, schema, path, document, visited) {
   if (schema.minItems !== void 0 && data.length < schema.minItems) {
-    return invalidSchemaResponseWithError$1(
-      new MinItemsViolationError$1(
+    return invalidSchemaResponseWithError(
+      new MinItemsViolationError(
         `Array at path '${path}' fails minItems constraint. Has ${data.length} items, needs at least ${schema.minItems}.`
       )
     );
   }
   if (schema.maxItems !== void 0 && data.length > schema.maxItems) {
-    return invalidSchemaResponseWithError$1(
-      new MaxItemsViolationError$1(
+    return invalidSchemaResponseWithError(
+      new MaxItemsViolationError(
         `Array at path '${path}' fails maxItems constraint. Has ${data.length} items, needs at most ${schema.maxItems}.`
       )
     );
   }
-  const errorCollector = new JsonSchemaErrorCollector$1();
+  const errorCollector = new JsonSchemaErrorCollector();
   data.forEach(
     (element, index) => errorCollector.append(
-      validateJsonSchema$1(element, schema.items, `${path}[${index}]`, document)
+      validateJsonSchemaInternal(
+        element,
+        schema.items,
+        `${path}[${index}]`,
+        document,
+        visited
+      )
     )
   );
   return errorCollector.toValidationResponse();
 }
-function validateScalar$1(data, schema, path) {
+function validateScalar(data, schema, path) {
   const schemaDataType = schema.type;
   const dataType = typeof data;
   if (schemaDataType === "integer") {
     if (dataType !== "number" || !Number.isInteger(data)) {
-      return invalidSchemaResponseWithError$1(incorrectTypeError$1("integer", dataType, path));
+      return invalidSchemaResponseWithError(incorrectTypeError("integer", dataType, path));
     }
   } else if (schemaDataType === "number") {
     if (dataType !== "number") {
-      return invalidSchemaResponseWithError$1(incorrectTypeError$1("number", dataType, path));
+      return invalidSchemaResponseWithError(incorrectTypeError("number", dataType, path));
     }
   } else if (schemaDataType === "string") {
     if (dataType !== "string") {
-      return invalidSchemaResponseWithError$1(incorrectTypeError$1("string", dataType, path));
+      return invalidSchemaResponseWithError(incorrectTypeError("string", dataType, path));
     }
   } else if (schemaDataType === "boolean") {
     if (dataType !== "boolean") {
-      return invalidSchemaResponseWithError$1(incorrectTypeError$1("boolean", dataType, path));
+      return invalidSchemaResponseWithError(incorrectTypeError("boolean", dataType, path));
     }
   } else if (schemaDataType === "null") {
     if (data !== null) {
-      return invalidSchemaResponseWithError$1(incorrectTypeError$1("null", dataType, path));
+      return invalidSchemaResponseWithError(incorrectTypeError("null", dataType, path));
     }
   } else {
-    return invalidSchemaResponseWithError$1(
-      new IncorrectTypeError$1(`Unknown schema data type: ${schemaDataType}.`)
+    return invalidSchemaResponseWithError(
+      new IncorrectTypeError(`Unknown schema data type: ${schemaDataType}.`)
     );
   }
-  return validSchemaResponse$1();
+  return validSchemaResponse();
 }
-function validateRef$1(data, schema, path, document) {
+function validateRef(data, schema, path, document, visited) {
   if (!schema.$ref.startsWith("#")) {
-    return invalidSchemaResponseWithError$1(
-      new InvalidRefError$1(
+    return invalidSchemaResponseWithError(
+      new InvalidRefError(
         `$ref values that do not refer to the current document are unsupported (must start with '#')`
       )
     );
   }
+  let refsForData = visited.get(data);
+  if (refsForData !== void 0 && refsForData.has(schema.$ref)) {
+    return validSchemaResponse();
+  }
+  if (refsForData === void 0) {
+    refsForData = /* @__PURE__ */ new Set();
+    visited.set(data, refsForData);
+  }
+  refsForData.add(schema.$ref);
   try {
-    const schemaToValidate = findSchemaAtPath$1(document, schema.$ref);
-    return validateJsonSchema$1(data, schemaToValidate, path, document);
+    const schemaToValidate = findSchemaAtPath(document, schema.$ref);
+    return validateJsonSchemaInternal(data, schemaToValidate, path, document, visited);
   } catch (e) {
-    return invalidSchemaResponseWithError$1(e);
+    return invalidSchemaResponseWithError(e);
+  } finally {
+    refsForData.delete(schema.$ref);
+    if (refsForData.size === 0) visited.delete(data);
   }
 }
-function validateEnum$1(data, enumValue, path) {
+function validateEnum(data, enumValue, path) {
   if (!enumValue.some((value) => deepEquals$1(value, data))) {
-    return invalidSchemaResponseWithError$1(
-      new JsonSchemaViolationError$1(
+    return invalidSchemaResponseWithError(
+      new JsonSchemaViolationError(
         `Data at ${path} did not match any values in enum. Expected value in: [${enumValue.map((value) => stringify$2(value)).join()}]`
       )
     );
   }
-  return validSchemaResponse$1();
+  return validSchemaResponse();
 }
-function validateConst$1(data, constValue, path) {
+function validateConst(data, constValue, path) {
   if (!deepEquals$1(constValue, data)) {
-    return invalidSchemaResponseWithError$1(
-      new JsonSchemaViolationError$1(
+    return invalidSchemaResponseWithError(
+      new JsonSchemaViolationError(
         `Data at ${path} did not match const. Expected: ${stringify$2(constValue)}`
       )
     );
   }
-  return validSchemaResponse$1();
+  return validSchemaResponse();
 }
-function findSchemaAtPath$1(document, ref) {
+function findSchemaAtPath(document, ref) {
   if (ref === "#") return document;
   const keys = ref.replace(/^#\//, "").split("/");
   let current = document;
@@ -97032,7 +97491,7 @@ function findSchemaAtPath$1(document, ref) {
   for (const key of keys) {
     path = `${path}/${key}`;
     if (current[key] === void 0) {
-      throw new InvalidRefError$1(
+      throw new InvalidRefError(
         `Invalid $ref value '${ref}'. Cannot find target schema at '${path}'`
       );
     }
@@ -97077,7 +97536,7 @@ function logError(error) {
  */
 function buildBaseImperativeInvoker(getCommand, transformResult) {
   return async (...params) => {
-    const command = getCommand({ params, assertIsValid: assertIsValid$1 });
+    const command = getCommand({ params, assertIsValid });
     try {
       return command.execute().then((result) => transformResult(result));
     } catch (error) {
@@ -97217,7 +97676,7 @@ function buildServiceDescriptor$4() {
 class LegacyImperativeBindingsService {
   bind(getCommand) {
     const invoke = async (config, requestContext, callback) => {
-      const command = getCommand({ config, assertIsValid: assertIsValid$1 });
+      const command = getCommand({ config, assertIsValid });
       try {
         const overrides = getOverridesForLegacyRequestContext(requestContext);
         const result = await command.execute(overrides);
@@ -97232,7 +97691,7 @@ class LegacyImperativeBindingsService {
       }
     };
     const subscribe = (config, requestContext, callback) => {
-      const command = getCommand({ config, assertIsValid: assertIsValid$1 });
+      const command = getCommand({ config, assertIsValid });
       let unsubscribe = () => {
       };
       try {
@@ -97291,13 +97750,7 @@ class GraphQLImperativeBindingsService {
         }
         return await buildBaseImperativeInvoker(getCommand, (result) => this.transformResult(result, exposeRefresh))(...params);
       } catch (error) {
-        logError$1(error);
-        return {
-          data: void 0,
-          errors: [
-            { message: "Internal error in GraphQL adapter occurred", locations: [] }
-          ]
-        };
+        return toGraphQLErrorResponse(error);
       }
     };
   }
@@ -97391,8 +97844,8 @@ class GraphQLLegacyImperativeBindingsService {
           config = result.value;
         }
       }
-      const command = getCommand({ config, assertIsValid: assertIsValid$1 });
       try {
+        const command = getCommand({ config, assertIsValid });
         const overrides = getOverridesForLegacyRequestContext(requestContext);
         const result = await command.execute(overrides);
         const consumerEmittedData = {
@@ -97409,13 +97862,7 @@ class GraphQLLegacyImperativeBindingsService {
         }
         callback(consumerEmittedData);
       } catch (error) {
-        logError$1(error);
-        callback({
-          data: void 0,
-          errors: [
-            { message: "Internal error in GraphQL adapter occurred", locations: [] }
-          ]
-        });
+        callback(toGraphQLErrorResponse(error));
       }
     };
     const subscribe = (config, requestContext, callback) => {
@@ -97433,35 +97880,41 @@ class GraphQLLegacyImperativeBindingsService {
           config = result.value;
         }
       }
-      const command = getCommand({ config, assertIsValid: assertIsValid$1 });
       let unsubscribe = () => {
       };
-      const overrides = getOverridesForLegacyRequestContext(requestContext);
-      command.execute(overrides).then((result) => {
-        const consumerEmittedData = {
-          data: void 0,
-          errors: void 0
-        };
-        if (result.isOk()) {
-          deepFreeze(result.value);
-          consumerEmittedData.data = result.value.data.data;
-          unsubscribe = result.value.subscribe(
-            (res) => {
-              handleEmit(res, callback);
-            }
-          );
-        } else {
-          const { data, errors } = toGraphQLResponseFromFailure$1(result.error.failure);
-          consumerEmittedData.data = data;
-          consumerEmittedData.errors = errors;
-          unsubscribe = result.error.subscribe(
-            (res) => {
-              handleEmit(res, callback);
-            }
-          );
-        }
-        callback(consumerEmittedData);
-      });
+      try {
+        const command = getCommand({ config, assertIsValid });
+        const overrides = getOverridesForLegacyRequestContext(requestContext);
+        command.execute(overrides).then((result) => {
+          const consumerEmittedData = {
+            data: void 0,
+            errors: void 0
+          };
+          if (result.isOk()) {
+            deepFreeze(result.value);
+            consumerEmittedData.data = result.value.data.data;
+            unsubscribe = result.value.subscribe(
+              (res) => {
+                handleEmit(res, callback);
+              }
+            );
+          } else {
+            const { data, errors } = toGraphQLResponseFromFailure$1(
+              result.error.failure
+            );
+            consumerEmittedData.data = data;
+            consumerEmittedData.errors = errors;
+            unsubscribe = result.error.subscribe(
+              (res) => {
+                handleEmit(res, callback);
+              }
+            );
+          }
+          callback(consumerEmittedData);
+        });
+      } catch (error) {
+        callback(toGraphQLErrorResponse(error));
+      }
       return () => {
         unsubscribe();
       };
@@ -97495,7 +97948,7 @@ class GraphQLMutationBindingsService {
             params[0] = result2.value;
           }
         }
-        const command = getCommand({ params, assertIsValid: assertIsValid$1 });
+        const command = getCommand({ params, assertIsValid });
         const result = await command.execute({ cacheControlConfig: { type: "no-cache" } });
         if (result.isOk()) {
           deepFreeze(result.value);
@@ -97504,13 +97957,7 @@ class GraphQLMutationBindingsService {
           return toGraphQLResponseFromFailure$1(result.error.failure);
         }
       } catch (error) {
-        logError$1(error);
-        return {
-          data: void 0,
-          errors: [
-            { message: "Internal error in GraphQL adapter occurred", locations: [] }
-          ]
-        };
+        return toGraphQLErrorResponse(error);
       }
     };
   }
@@ -97578,8 +98025,8 @@ function sanitize(obj) {
   return new Sanitizer(obj).sanitize();
 }
 function isIncompleteConfigError(err) {
-  return err instanceof MissingRequiredPropertyError$1 || err instanceof JsonSchemaViolationError$1 && err.validationErrors.find(
-    (validationError) => validationError instanceof MissingRequiredPropertyError$1
+  return err instanceof MissingRequiredPropertyError || err instanceof JsonSchemaViolationError && err.validationErrors.find(
+    (validationError) => validationError instanceof MissingRequiredPropertyError
   ) !== void 0;
 }
 class CommandWireAdapterConstructor {
@@ -97665,11 +98112,15 @@ class CommandWireAdapterConstructor {
     }
     if (this.configSchema) {
       try {
-        assertIsValid$1(this.config, this.configSchema);
+        assertIsValid(this.config, this.configSchema);
       } catch (err) {
         if (isIncompleteConfigError(err)) {
           return;
         }
+        if (err instanceof JsonSchemaViolationError) {
+          this.handleConfigSchemaViolation(err);
+          return;
+        }
         throw err;
       }
     }
@@ -97722,6 +98173,16 @@ class CommandWireAdapterConstructor {
   handleExecutionThrow(error) {
     emitError(this.callback, error);
   }
+  /**
+   * Hook for subclasses to handle a JsonSchemaViolationError from the config
+   * schema assertion. The default re-throws so legacy non-GraphQL wire
+   * adapters keep their existing throw behavior. Overrides are expected to
+   * either emit an error result or re-throw — silently returning will
+   * swallow the error.
+   */
+  handleConfigSchemaViolation(error) {
+    throw error;
+  }
   unsubscribe() {
     if (this.unsubscriber) {
       this.unsubscriber();
@@ -97814,16 +98275,14 @@ class GraphQLCommandWireAdapterConstructor extends CommandWireAdapterConstructor
         this.callback(consumerEmittedData);
       }
     } catch (e) {
-      logError$1(e);
       this.handleExecutionThrow(e);
     }
   }
-  handleExecutionThrow(e) {
-    logError$1(e);
-    this.callback({
-      data: void 0,
-      errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
-    });
+  handleExecutionThrow(error) {
+    this.callback(toGraphQLErrorResponse(error));
+  }
+  handleConfigSchemaViolation(error) {
+    this.handleExecutionThrow(error);
   }
   update(config, _context) {
     this.unsubscribe();
@@ -98475,9 +98934,11 @@ class NimbusDurableCacheInclusionPolicy extends DurableCacheInclusionPolicy {
         return entries.length > 0 ? this.store.setEntries(entries) : Promise.resolve();
     }
     find(_query) {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
         throw new Error('find not supported on the NimbusDurableCacheInclusionPolicy');
     }
     findAndModify(_query, _cacheUpdate) {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
         throw new Error('findAndModify not supported on the NimbusDurableCacheInclusionPolicy');
     }
     registerListener() {
@@ -98503,7 +98964,7 @@ class NimbusDurableCacheInclusionPolicy extends DurableCacheInclusionPolicy {
                         });
                     });
                 }
-                // TODO: onestore doesnt support cache eviction yet
+                // TODO [W-19368859]: onestore doesnt support cache eviction yet
                 // if (evictKeys.size > 0) {
                 //     evictKeys.forEach((key) => {
                 //         this.services.cache.evict(key);
@@ -98598,6 +99059,7 @@ class NimbusSqliteOneStoreCache {
     batchQuery(operations) {
         return new Promise((resolve, reject) => {
             this.sqlStore.batchOperations(operations, (error) => {
+                // eslint-disable-next-line no-unused-expressions
                 error ? reject(error) : resolve();
             });
         });
@@ -98673,7 +99135,7 @@ function initializeOneStore(sqliteStore, luvio) {
         buildServiceDescriptor$7(),
         buildServiceDescriptor$1$1(),
         buildServiceDescriptor$2(),
-        // TODO[@W-18753648]: See note above.
+        // TODO [W-18753648]: See note above.
         // buildStreamingCommandServiceDescriptor(),
         // buildNdJsonServiceDescriptor(),
         // buildSseCommandServiceDescriptor(),
@@ -98932,378 +99394,12 @@ register$1({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$2,
 });
-// version: 1.433.0-8a15a98f24
+// version: 1.435.0-5818ce3c48
 
 const { create: create$2, keys: keys$2 } = Object;
 const { stringify, parse } = JSON;
 const { isArray: isArray$3 } = Array;
 
-/*!
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-class JsonSchemaViolationError extends Error {
-  constructor(message, validationErrors) {
-    super(message);
-    this.validationErrors = [];
-    this.validationErrors = validationErrors || [];
-  }
-}
-class MinItemsViolationError extends JsonSchemaViolationError {
-}
-class MaxItemsViolationError extends JsonSchemaViolationError {
-}
-class IncorrectTypeError extends JsonSchemaViolationError {
-}
-class AdditionalPropertiesError extends JsonSchemaViolationError {
-}
-class MissingRequiredPropertyError extends JsonSchemaViolationError {
-}
-class InvalidRefError extends JsonSchemaViolationError {
-}
-class JsonSchemaErrorCollector {
-  constructor() {
-    this.errors = [];
-  }
-  add(error) {
-    this.errors.push(error);
-  }
-  append(response) {
-    if (response.isErr()) {
-      this.errors.push(...response.error);
-    }
-  }
-  hasErrors() {
-    return this.errors.length > 0;
-  }
-  prepend(error) {
-    this.errors.unshift(error);
-  }
-  toValidationResponse() {
-    return !this.hasErrors() ? ok$4(true) : err$4(this.errors);
-  }
-}
-function createThrowableError(errors) {
-  if (errors[0] instanceof MinItemsViolationError) {
-    return new MinItemsViolationError(errors[0].message, errors);
-  }
-  if (errors[0] instanceof MaxItemsViolationError) {
-    return new MaxItemsViolationError(errors[0].message, errors);
-  }
-  if (errors[0] instanceof IncorrectTypeError) {
-    return new IncorrectTypeError(errors[0].message, errors);
-  }
-  if (errors[0] instanceof AdditionalPropertiesError) {
-    return new AdditionalPropertiesError(errors[0].message, errors);
-  }
-  if (errors[0] instanceof MissingRequiredPropertyError) {
-    return new MissingRequiredPropertyError(errors[0].message, errors);
-  }
-  if (errors[0] instanceof InvalidRefError) {
-    return new InvalidRefError(errors[0].message, errors);
-  }
-  return new JsonSchemaViolationError(errors[0].message, errors);
-}
-function assertIsValid(data, schema) {
-  const validationResponse = validateJsonSchema(data, schema);
-  if (validationResponse.isErr()) {
-    throw createThrowableError(validationResponse.error);
-  }
-}
-function incorrectTypeError(expected, actual, path) {
-  return new IncorrectTypeError(
-    `Expected type ${expected} at path '${path}', found type ${actual}.`
-  );
-}
-function validSchemaResponse() {
-  return ok$4(true);
-}
-function invalidSchemaResponseWithError(error) {
-  return err$4([error]);
-}
-function validateJsonSchema(data, schema, path = "$", document = schema) {
-  if (schema === true) return validSchemaResponse();
-  if (schema === false)
-    return invalidSchemaResponseWithError(
-      new JsonSchemaViolationError(`Data at ${path} has schema 'false'`)
-    );
-  const dataType = data === null ? "null" : Array.isArray(data) ? "array" : typeof data;
-  const errorCollector = new JsonSchemaErrorCollector();
-  if ("anyOf" in schema) {
-    errorCollector.append(validateAnyOf(data, schema, path, document));
-  } else if ("oneOf" in schema) {
-    errorCollector.append(validateOneOf(data, schema, path, document));
-  } else if ("allOf" in schema) {
-    errorCollector.append(validateAllOf(data, schema, path, document));
-  } else if ("not" in schema) {
-    errorCollector.append(validateNot(data, schema, path, document));
-  } else if ("$ref" in schema) {
-    errorCollector.append(validateRef(data, schema, path, document));
-  } else if ("type" in schema) {
-    if (schema.type === "object") {
-      if (dataType !== "object") {
-        errorCollector.add(incorrectTypeError("object", dataType, path));
-      } else {
-        errorCollector.append(
-          validateObject(data, schema, path, document)
-        );
-      }
-    } else if (schema.type === "array") {
-      if (dataType !== "array") {
-        errorCollector.add(incorrectTypeError("array", dataType, path));
-      } else {
-        errorCollector.append(
-          validateArray(data, schema, path, document)
-        );
-      }
-    } else {
-      errorCollector.append(
-        validateScalar(data, schema, path)
-      );
-    }
-  }
-  if (schema.enum) {
-    errorCollector.append(validateEnum(data, schema.enum, path));
-  }
-  if (schema.const) {
-    errorCollector.append(validateConst(data, schema.const, path));
-  }
-  return errorCollector.toValidationResponse();
-}
-function validateAnyOf(data, schema, path, document) {
-  let isValid = false;
-  const errorCollector = new JsonSchemaErrorCollector();
-  for (let i = 0, { length } = schema.anyOf; i < length; i++) {
-    const element = schema.anyOf[i];
-    const validationResponse = validateJsonSchema(
-      data,
-      element,
-      `${path}.anyOf[${i}]`,
-      document
-    );
-    if (validationResponse.isOk()) {
-      isValid = true;
-      break;
-    } else {
-      errorCollector.append(validationResponse);
-    }
-  }
-  if (!isValid) {
-    errorCollector.prepend(
-      new JsonSchemaViolationError(`Data at ${path} did not match any subschema in anyOf.`)
-    );
-    return errorCollector.toValidationResponse();
-  }
-  return validSchemaResponse();
-}
-function validateOneOf(data, schema, path, document) {
-  let validSubShemaPaths = [];
-  const errorCollector = new JsonSchemaErrorCollector();
-  for (let i = 0, { length } = schema.oneOf; i < length; i++) {
-    const element = schema.oneOf[i];
-    const oneOfPath = `${path}.oneOf[${i}]`;
-    const validationResponse = validateJsonSchema(data, element, oneOfPath, document);
-    if (validationResponse.isOk()) {
-      validSubShemaPaths.push(oneOfPath);
-    } else {
-      errorCollector.append(validationResponse);
-    }
-  }
-  if (validSubShemaPaths.length === 0) {
-    errorCollector.prepend(
-      new JsonSchemaViolationError(`Data at ${path} did not match any subschema in oneOf.`)
-    );
-    return errorCollector.toValidationResponse();
-  } else if (validSubShemaPaths.length > 1) {
-    errorCollector.prepend(
-      new JsonSchemaViolationError(
-        `Data at ${path} matched multiple subschemas: [${validSubShemaPaths.join(", ")}].`
-      )
-    );
-    return errorCollector.toValidationResponse();
-  }
-  return validSchemaResponse();
-}
-function validateAllOf(data, schema, path, document) {
-  let isValid = true;
-  const errorCollector = new JsonSchemaErrorCollector();
-  for (let i = 0, { length } = schema.allOf; i < length; i++) {
-    const element = schema.allOf[i];
-    const validationResponse = validateJsonSchema(
-      data,
-      element,
-      `${path}.allOf[${i}]`,
-      document
-    );
-    if (!validationResponse.isOk()) {
-      errorCollector.append(validationResponse);
-      isValid = false;
-    }
-  }
-  if (!isValid) {
-    errorCollector.prepend(
-      new JsonSchemaViolationError(`Data at ${path} did not match some subschemas in allOf.`)
-    );
-  }
-  return errorCollector.toValidationResponse();
-}
-function validateNot(data, schema, path, document) {
-  const validationResponse = validateJsonSchema(data, schema.not, path, document);
-  if (validationResponse.isOk()) {
-    return invalidSchemaResponseWithError(
-      new JsonSchemaViolationError(
-        `Data at ${path} validated against the schema of a not clause.`
-      )
-    );
-  }
-  return validSchemaResponse();
-}
-function validateObject(data, schema, path, document) {
-  const schemaKeys = Object.keys(schema.properties);
-  const requiredKeys = new Set(schema.required);
-  const schemaKeySet = new Set(schemaKeys);
-  const errorCollector = new JsonSchemaErrorCollector();
-  Object.keys(data).forEach((key) => {
-    if (!schemaKeySet.has(key)) {
-      errorCollector.append(
-        validateJsonSchema(
-          data[key],
-          schema.additionalProperties,
-          `${path}.additionalProperties[${key}]`,
-          document
-        )
-      );
-    }
-  });
-  for (let i = 0, length = schemaKeys.length; i < length; i++) {
-    const key = schemaKeys[i];
-    const keyInData = key in data && data[key] !== void 0;
-    if (requiredKeys.has(key) && !keyInData) {
-      errorCollector.add(
-        new MissingRequiredPropertyError(
-          `Object at path '${path}' is missing required property '${key}'.`
-        )
-      );
-    }
-    if (keyInData) {
-      errorCollector.append(
-        validateJsonSchema(
-          data[key],
-          schema.properties[key],
-          `${path}.${key}`,
-          document
-        )
-      );
-    }
-  }
-  return errorCollector.toValidationResponse();
-}
-function validateArray(data, schema, path, document) {
-  if (schema.minItems !== void 0 && data.length < schema.minItems) {
-    return invalidSchemaResponseWithError(
-      new MinItemsViolationError(
-        `Array at path '${path}' fails minItems constraint. Has ${data.length} items, needs at least ${schema.minItems}.`
-      )
-    );
-  }
-  if (schema.maxItems !== void 0 && data.length > schema.maxItems) {
-    return invalidSchemaResponseWithError(
-      new MaxItemsViolationError(
-        `Array at path '${path}' fails maxItems constraint. Has ${data.length} items, needs at most ${schema.maxItems}.`
-      )
-    );
-  }
-  const errorCollector = new JsonSchemaErrorCollector();
-  data.forEach(
-    (element, index) => errorCollector.append(
-      validateJsonSchema(element, schema.items, `${path}[${index}]`, document)
-    )
-  );
-  return errorCollector.toValidationResponse();
-}
-function validateScalar(data, schema, path) {
-  const schemaDataType = schema.type;
-  const dataType = typeof data;
-  if (schemaDataType === "integer") {
-    if (dataType !== "number" || !Number.isInteger(data)) {
-      return invalidSchemaResponseWithError(incorrectTypeError("integer", dataType, path));
-    }
-  } else if (schemaDataType === "number") {
-    if (dataType !== "number") {
-      return invalidSchemaResponseWithError(incorrectTypeError("number", dataType, path));
-    }
-  } else if (schemaDataType === "string") {
-    if (dataType !== "string") {
-      return invalidSchemaResponseWithError(incorrectTypeError("string", dataType, path));
-    }
-  } else if (schemaDataType === "boolean") {
-    if (dataType !== "boolean") {
-      return invalidSchemaResponseWithError(incorrectTypeError("boolean", dataType, path));
-    }
-  } else if (schemaDataType === "null") {
-    if (data !== null) {
-      return invalidSchemaResponseWithError(incorrectTypeError("null", dataType, path));
-    }
-  } else {
-    return invalidSchemaResponseWithError(
-      new IncorrectTypeError(`Unknown schema data type: ${schemaDataType}.`)
-    );
-  }
-  return validSchemaResponse();
-}
-function validateRef(data, schema, path, document) {
-  if (!schema.$ref.startsWith("#")) {
-    return invalidSchemaResponseWithError(
-      new InvalidRefError(
-        `$ref values that do not refer to the current document are unsupported (must start with '#')`
-      )
-    );
-  }
-  try {
-    const schemaToValidate = findSchemaAtPath(document, schema.$ref);
-    return validateJsonSchema(data, schemaToValidate, path, document);
-  } catch (e) {
-    return invalidSchemaResponseWithError(e);
-  }
-}
-function validateEnum(data, enumValue, path) {
-  if (!enumValue.some((value) => deepEquals$2(value, data))) {
-    return invalidSchemaResponseWithError(
-      new JsonSchemaViolationError(
-        `Data at ${path} did not match any values in enum. Expected value in: [${enumValue.map((value) => stringify$9(value)).join()}]`
-      )
-    );
-  }
-  return validSchemaResponse();
-}
-function validateConst(data, constValue, path) {
-  if (!deepEquals$2(constValue, data)) {
-    return invalidSchemaResponseWithError(
-      new JsonSchemaViolationError(
-        `Data at ${path} did not match const. Expected: ${stringify$9(constValue)}`
-      )
-    );
-  }
-  return validSchemaResponse();
-}
-function findSchemaAtPath(document, ref) {
-  if (ref === "#") return document;
-  const keys = ref.replace(/^#\//, "").split("/");
-  let current = document;
-  let path = "#";
-  for (const key of keys) {
-    path = `${path}/${key}`;
-    if (current[key] === void 0) {
-      throw new InvalidRefError(
-        `Invalid $ref value '${ref}'. Cannot find target schema at '${path}'`
-      );
-    }
-    current = current[key];
-  }
-  return current;
-}
-
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -99352,35 +99448,35 @@ function extractValue(valueNode, variableDefinitions, expectedType) {
 function extractVariableValue(variableName, variableDefinitions) {
   const variable = variableDefinitions[variableName];
   if (!variable) {
-    return err$4(
+    return err$3(
       new Error(`Variable '${variableName}' was used in the query but was not defined`)
     );
   }
   if (variable.value !== void 0) {
-    return ok$4(variable.value);
+    return ok$3(variable.value);
   }
   if (variable.definition.defaultValue) {
     return extractValue(variable.definition.defaultValue, variableDefinitions);
   }
-  return ok$4(void 0);
+  return ok$3(void 0);
 }
 function validateExpectedType(value, expectedType) {
   if (!expectedType) {
-    return ok$4(value);
+    return ok$3(value);
   }
   if (value === null) {
     if (expectedType.nullable) {
-      return ok$4(value);
+      return ok$3(value);
     } else {
-      return err$4(new Error(`Expected ${expectedType.type}, but got null`));
+      return err$3(new Error(`Expected ${expectedType.type}, but got null`));
     }
   }
   const actualType = typeof value;
   if (actualType === expectedType.type) {
-    return ok$4(value);
+    return ok$3(value);
   }
   const expectedTypeString = expectedType.nullable ? `${expectedType.type} | null` : expectedType.type;
-  return err$4(
+  return err$3(
     new Error(`Expected ${expectedTypeString}, but got ${actualType}: ${JSON.stringify(value)}`)
   );
 }
@@ -99423,10 +99519,10 @@ function findExecutableOperation(input) {
     (def) => def.kind === Kind$1.OPERATION_DEFINITION
   );
   if (operations.length === 0) {
-    return err$4(new Error("No operations found in query"));
+    return err$3(new Error("No operations found in query"));
   }
   if (operations.length === 1 && !input.operationName) {
-    return ok$4(operations[0]);
+    return ok$3(operations[0]);
   }
   if (input.operationName) {
     const specifiedOperation = operations.find((op) => {
@@ -99434,16 +99530,16 @@ function findExecutableOperation(input) {
       return ((_a = op.name) == null ? void 0 : _a.value) === input.operationName;
     });
     if (specifiedOperation) {
-      return ok$4(specifiedOperation);
+      return ok$3(specifiedOperation);
     }
-    return err$4(new Error(`Operation "${input.operationName}" not found in query`));
+    return err$3(new Error(`Operation "${input.operationName}" not found in query`));
   }
-  return err$4(new Error("Multiple operations found in query, and no operation name provided"));
+  return err$3(new Error("Multiple operations found in query, and no operation name provided"));
 }
 function buildGraphQLInputExtension(input) {
   const operationResult = findExecutableOperation(input);
   if (operationResult.isErr()) {
-    return err$4(operationResult.error);
+    return err$3(operationResult.error);
   }
   const operation = operationResult.value;
   const selections = operation.selectionSet.selections;
@@ -99460,7 +99556,7 @@ function buildGraphQLInputExtension(input) {
     prev[fragment.name.value] = fragment;
     return prev;
   }, {});
-  return ok$4({
+  return ok$3({
     selections,
     request: { definitions: { variables, fragments } },
     parentFieldSelection: void 0
@@ -99618,13 +99714,13 @@ function collectFieldNames(selections, fragments) {
 }
 function buildFieldKey(canonicalFieldName, fieldArguments, variables) {
   if (fieldArguments === void 0 || fieldArguments.length === 0) {
-    return ok$4(canonicalFieldName);
+    return ok$3(canonicalFieldName);
   }
   const formattedArguments = {};
   for (const arg of fieldArguments) {
     const result = extractValue(arg.value, variables);
     if (result.isErr()) {
-      return err$4(
+      return err$3(
         new Error(
           `Failed to extract argument '${arg.name.value}' for field '${canonicalFieldName}': ${result.error.message}`
         )
@@ -99632,7 +99728,7 @@ function buildFieldKey(canonicalFieldName, fieldArguments, variables) {
     }
     formattedArguments[arg.name.value] = result.value;
   }
-  return ok$4(`${canonicalFieldName}::${stableJSONStringify$3({ args: formattedArguments })}`);
+  return ok$3(`${canonicalFieldName}::${stableJSONStringify$3({ args: formattedArguments })}`);
 }
 ({
   kind: Kind$1.FIELD,
@@ -99657,17 +99753,17 @@ function extractIfArgument(directive, variables, directiveName) {
   var _a;
   const ifArg = (_a = directive.arguments) == null ? void 0 : _a.find((arg) => arg.name.value === "if");
   if (!ifArg) {
-    return err$4(new Error(`@${directiveName} directive requires an 'if' argument`));
+    return err$3(new Error(`@${directiveName} directive requires an 'if' argument`));
   }
   const result = extractValue(ifArg.value, variables, { type: "boolean", nullable: false });
   if (result.isErr()) {
-    return err$4(result.error);
+    return err$3(result.error);
   }
-  return ok$4(result.value);
+  return ok$3(result.value);
 }
 function shouldSkip(selection, variables) {
   if (!selection.directives || selection.directives.length === 0) {
-    return ok$4(false);
+    return ok$3(false);
   }
   for (const directive of selection.directives) {
     if (directive.name.value === "skip") {
@@ -99676,7 +99772,7 @@ function shouldSkip(selection, variables) {
         return ifResult;
       }
       if (ifResult.value === true) {
-        return ok$4(true);
+        return ok$3(true);
       }
     }
     if (directive.name.value === "include") {
@@ -99685,11 +99781,11 @@ function shouldSkip(selection, variables) {
         return ifResult;
       }
       if (ifResult.value === false) {
-        return ok$4(true);
+        return ok$3(true);
       }
     }
   }
-  return ok$4(false);
+  return ok$3(false);
 }
 class BaseScalarFieldDef {
   constructor(nullable) {
@@ -99697,11 +99793,11 @@ class BaseScalarFieldDef {
   }
   write(_cache, input) {
     if (input.data === void 0) {
-      return ok$4({ type: "missing" });
+      return ok$3({ type: "missing" });
     }
     if (input.data === null) {
       if (!this.nullable) {
-        return err$4([
+        return err$3([
           {
             type: "unknown",
             error: new Error(
@@ -99711,14 +99807,14 @@ class BaseScalarFieldDef {
         ]);
       }
     }
-    return ok$4({ type: "data", data: input.data });
+    return ok$3({ type: "data", data: input.data });
   }
   read(_cache, input) {
     const normalizedData = input.normalizedData;
     if (normalizedData.type === "missing") {
-      return ok$4(void 0);
+      return ok$3(void 0);
     }
-    return ok$4(normalizedData.data);
+    return ok$3(normalizedData.data);
   }
   augmentSelections(input) {
     return input;
@@ -99740,11 +99836,11 @@ class BaseArrayFieldDef {
   }
   write(cache, input) {
     if (input.data === void 0) {
-      return ok$4({ type: "missing" });
+      return ok$3({ type: "missing" });
     }
     if (input.data === null) {
       if (!this.nullable) {
-        return err$4([
+        return err$3([
           {
             type: "unknown",
             error: new Error(
@@ -99753,10 +99849,10 @@ class BaseArrayFieldDef {
           }
         ]);
       }
-      return ok$4({ type: "data", data: input.data });
+      return ok$3({ type: "data", data: input.data });
     }
     if (!Array.isArray(input.data)) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -99784,18 +99880,18 @@ class BaseArrayFieldDef {
       }
     });
     if (arrayNormalizationErrors.length > 0) {
-      return err$4(arrayNormalizationErrors);
+      return err$3(arrayNormalizationErrors);
     }
-    return ok$4({ type: "data", data: normalizedArray });
+    return ok$3({ type: "data", data: normalizedArray });
   }
   read(cache, input) {
     const normalizedData = input.normalizedData;
     if (normalizedData.type === "missing") {
-      return ok$4(void 0);
+      return ok$3(void 0);
     }
     if (normalizedData.data === null) {
       if (!this.nullable) {
-        return err$4([
+        return err$3([
           {
             type: "unknown",
             error: new Error(
@@ -99804,10 +99900,10 @@ class BaseArrayFieldDef {
           }
         ]);
       }
-      return ok$4({ type: "data", data: null });
+      return ok$3({ type: "data", data: null });
     }
     if (!Array.isArray(normalizedData.data)) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -99832,9 +99928,9 @@ class BaseArrayFieldDef {
       }
     });
     if (arrayDenormalizationErrors.length > 0) {
-      return err$4(arrayDenormalizationErrors);
+      return err$3(arrayDenormalizationErrors);
     }
-    return ok$4(denormalizedArray);
+    return ok$3(denormalizedArray);
   }
 }
 class BaseObjectFieldDef {
@@ -99851,7 +99947,7 @@ class BaseObjectFieldDef {
   write(cache, input) {
     var _a;
     if (!input.selection.selectionSet) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -99861,11 +99957,11 @@ class BaseObjectFieldDef {
       ]);
     }
     if (input.data === void 0) {
-      return ok$4({ type: "missing" });
+      return ok$3({ type: "missing" });
     }
     if (input.data === null) {
       if (!this.nullable) {
-        return err$4([
+        return err$3([
           {
             type: "unknown",
             error: new Error(
@@ -99874,7 +99970,7 @@ class BaseObjectFieldDef {
           }
         ]);
       }
-      return ok$4({ type: "data", data: null });
+      return ok$3({ type: "data", data: null });
     }
     const writeResult = this.repository.write(cache, {
       ...input,
@@ -99887,12 +99983,12 @@ class BaseObjectFieldDef {
     if (writeResult.isErr()) {
       return writeResult;
     }
-    return ok$4({ type: "data", data: writeResult.value });
+    return ok$3({ type: "data", data: writeResult.value });
   }
   read(cache, input) {
     var _a;
     if (!input.selection.selectionSet) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -99903,11 +99999,11 @@ class BaseObjectFieldDef {
     }
     const normalizedData = input.normalizedData;
     if (normalizedData.type === "missing") {
-      return ok$4(void 0);
+      return ok$3(void 0);
     }
     if (normalizedData.data === null) {
       if (!this.nullable) {
-        return err$4([
+        return err$3([
           {
             type: "unknown",
             error: new Error(
@@ -99916,7 +100012,7 @@ class BaseObjectFieldDef {
           }
         ]);
       }
-      return ok$4(null);
+      return ok$3(null);
     }
     return this.repository.read(cache, {
       ...input,
@@ -100199,7 +100295,7 @@ class BaseGraphQLTypeRepository {
     var _a;
     const fieldDef = this.getFieldDef(input, selection);
     if (!fieldDef) {
-      return err$4(
+      return err$3(
         new Error(
           `Unknown field "${selection.name.value}" on type "${this.typeName}". Expected one of fields ${Object.keys(this.fields)}.`
         )
@@ -100210,10 +100306,10 @@ class BaseGraphQLTypeRepository {
       input.request.definitions.variables
     );
     if (cacheFieldKeyResult.isErr()) {
-      return err$4(cacheFieldKeyResult.error);
+      return err$3(cacheFieldKeyResult.error);
     }
     const cacheFieldKey = cacheFieldKeyResult.value;
-    return ok$4((_a = input.existingNormalizedData || input.normalizedData) == null ? void 0 : _a[cacheFieldKey]);
+    return ok$3((_a = input.existingNormalizedData || input.normalizedData) == null ? void 0 : _a[cacheFieldKey]);
   }
   denormalizeFieldSelection(cache, input, selection, errorCollector) {
     var _a;
@@ -100319,22 +100415,22 @@ class BaseGraphQLTypeRepository {
       return shouldSkipResult;
     }
     if (shouldSkipResult.value) {
-      return ok$4(false);
+      return ok$3(false);
     }
     return this.satisfiesFragmentTypeCondition(input, fragment);
   }
   satisfiesFragmentTypeCondition(_input, fragment) {
     if (!fragment.typeCondition) {
-      return ok$4(true);
+      return ok$3(true);
     }
     const conditionalTypeName = fragment.typeCondition.name.value;
     if (conditionalTypeName === this.typeName) {
-      return ok$4(true);
+      return ok$3(true);
     }
     if (this.implementedInterfaces.includes(conditionalTypeName)) {
-      return ok$4(true);
+      return ok$3(true);
     }
-    return ok$4(false);
+    return ok$3(false);
   }
   getCacheKeyFieldArguments(selection) {
     return selection.arguments;
@@ -100393,7 +100489,7 @@ class IdentifiableGraphQLTypeRepository extends IdentifiableTypeRepository {
     const key = this.buildKey(this.buildKeyParams(input));
     const normalized = this.normalizeData(cache, input);
     if (normalized.isErr()) {
-      return err$4(normalized.error);
+      return err$3(normalized.error);
     }
     const existing = cache.get(key);
     if (!deepEquals$2(existing == null ? void 0 : existing.value, normalized.value)) {
@@ -100402,7 +100498,7 @@ class IdentifiableGraphQLTypeRepository extends IdentifiableTypeRepository {
         metadata: this.cacheMetadata
       });
     }
-    return ok$4({
+    return ok$3({
       type: "link",
       linkedKey: key
     });
@@ -100417,7 +100513,7 @@ class IdentifiableGraphQLTypeRepository extends IdentifiableTypeRepository {
     if (normalizeDataResult.isErr()) {
       return normalizeDataResult;
     }
-    return ok$4(
+    return ok$3(
       deepMerge$2(
         {},
         (existingNormalizedData == null ? void 0 : existingNormalizedData.value) || {},
@@ -100487,7 +100583,7 @@ class GraphQLDocumentRootTypeRepository extends IdentifiableGraphQLTypeRepositor
     if (result.isErr()) {
       return result;
     }
-    return ok$4({
+    return ok$3({
       data: result.value
     });
   }
@@ -100495,7 +100591,7 @@ class GraphQLDocumentRootTypeRepository extends IdentifiableGraphQLTypeRepositor
     var _a;
     const operationResult = findExecutableOperation(input);
     if (operationResult.isErr()) {
-      return err$4(operationResult.error);
+      return err$3(operationResult.error);
     }
     const operation = operationResult.value;
     const fragmentDefinitions = input.query.definitions.filter(
@@ -100518,7 +100614,7 @@ class GraphQLDocumentRootTypeRepository extends IdentifiableGraphQLTypeRepositor
       ...operation,
       selectionSet: { kind: Kind$1.SELECTION_SET, selections: augmentedOperationSelections }
     };
-    return ok$4({
+    return ok$3({
       ...input.query,
       definitions: [
         ...input.query.definitions.filter((def) => def.kind !== Kind$1.FRAGMENT_DEFINITION).map((def) => {
@@ -100553,7 +100649,7 @@ class BaseInterfaceRepository {
   }
   write(cache, input) {
     if (typeof input.data !== "object") {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(`Got a non-object value for ${this.typeName} field"`)
@@ -100563,7 +100659,7 @@ class BaseInterfaceRepository {
     const discriminator = this.getTypeDiscriminator(input.data, input.selections);
     const concreteTypeRepository = this.possibleTypes[discriminator];
     if (!concreteTypeRepository) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -100574,7 +100670,7 @@ class BaseInterfaceRepository {
     }
     const selectionErr = this.verifyInterfaceFields(input.selections);
     if (selectionErr) {
-      return err$4(selectionErr);
+      return err$3(selectionErr);
     }
     const normalizeInput = {
       ...input,
@@ -100586,14 +100682,14 @@ class BaseInterfaceRepository {
     };
     const result = concreteTypeRepository.write(cache, normalizeInput);
     if (result.isOk()) {
-      return ok$4({ discriminator, data: result.value });
+      return ok$3({ discriminator, data: result.value });
     }
     return result;
   }
   read(cache, input) {
     const unionRep = input.normalizedData;
     if (typeof unionRep.data !== "object" || unionRep.data === null) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(`Got a non-object value for ${this.typeName} field.`)
@@ -100603,7 +100699,7 @@ class BaseInterfaceRepository {
     const discriminator = unionRep.discriminator;
     const concreteRepository = this.possibleTypes[discriminator];
     if (!concreteRepository) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -100614,7 +100710,7 @@ class BaseInterfaceRepository {
     }
     const selectionErr = this.verifyInterfaceFields(input.selections);
     if (selectionErr) {
-      return err$4(selectionErr);
+      return err$3(selectionErr);
     }
     const denormalizeInput = {
       ...input,
@@ -100719,7 +100815,7 @@ class BaseUnionRepository {
   }
   write(cache, input) {
     if (typeof input.data !== "object") {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(`Got a non-object value for ${this.typeName} field"`)
@@ -100729,7 +100825,7 @@ class BaseUnionRepository {
     const discriminator = this.getTypeDiscriminator(input.data, input.selections);
     const concreteTypeRepository = this.possibleTypes[discriminator];
     if (!concreteTypeRepository) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -100740,7 +100836,7 @@ class BaseUnionRepository {
     }
     const selectionErr = this.verifyUnionFields(input.selections);
     if (selectionErr) {
-      return err$4(selectionErr);
+      return err$3(selectionErr);
     }
     const normalizeInput = {
       ...input,
@@ -100752,14 +100848,14 @@ class BaseUnionRepository {
     };
     const result = concreteTypeRepository.write(cache, normalizeInput);
     if (result.isOk()) {
-      return ok$4({ discriminator, data: result.value });
+      return ok$3({ discriminator, data: result.value });
     }
     return result;
   }
   read(cache, input) {
     const unionRep = input.normalizedData;
     if (typeof unionRep.data !== "object" || unionRep.data === null) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(`Got a non-object value for ${this.typeName} field.`)
@@ -100769,7 +100865,7 @@ class BaseUnionRepository {
     const discriminator = unionRep.discriminator;
     const concreteRepository = this.possibleTypes[discriminator];
     if (!concreteRepository) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -100780,7 +100876,7 @@ class BaseUnionRepository {
     }
     const selectionErr = this.verifyUnionFields(input.selections);
     if (selectionErr) {
-      return err$4(selectionErr);
+      return err$3(selectionErr);
     }
     const denormalizeInput = {
       ...input,
@@ -105299,7 +105395,7 @@ function dataSatisfiesFragmentTypeCondition(input, fragment) {
  * @param typeName - The repository type name for error messages
  * @returns Result<boolean, Error> - true if the fragment type condition is satisfied
  */
-function genericSatisfiesFragmentTypeCondition(superSatisfiesFragmentTypeCondition, input, fragment, typeName) {
+function genericSatisfiesFragmentTypeCondition(superSatisfiesFragmentTypeCondition, input, fragment, _typeName) {
     // First try the base class implementation
     const result = superSatisfiesFragmentTypeCondition(input, fragment);
     if (result.isErr() || result.value) {
@@ -105767,7 +105863,7 @@ class SetupRecordAggregateRepository extends Setup__SetupRecordAggregateReposito
 }
 
 class PolymorphicParentRelationshipRepository extends PolymorphicParentRelationshipRepository$1 {
-    getTypeDiscriminator(data, _selections) {
+    getTypeDiscriminator(_data, _selections) {
         // Hardcoded to record representation since that's the only type of parent
         // relationship possible
         return 'RecordRepresentation';
@@ -105807,7 +105903,7 @@ class SetupEdgeRepository extends Setup__SetupEdgeRepository {
 }
 
 class PolymorphicAggregateParentRelationshipRepository extends PolymorphicAggregateParentRelationshipRepository$1 {
-    getTypeDiscriminator(data, _selections) {
+    getTypeDiscriminator(_data, _selections) {
         // Hardcoded to record aggregate since that's the only type of parent
         // relationship possible
         return 'RecordAggregate';
@@ -105864,6 +105960,7 @@ class RecordDeletePayloadRepository extends RecordDeletePayloadRepository$1 {
         let idFieldSelection = input.selections.find((selection) => selection.kind === 'Field' && selection.name.value === 'Id');
         // If Id exists in data but wasn't asked for, synthesize the selection like RecordRepresentation does
         if (input.data.Id !== undefined && !idFieldSelection) {
+            // eslint-disable-next-line no-param-reassign
             input = {
                 ...input,
                 selections: [
@@ -105911,7 +106008,7 @@ class SetupConnectionRepository extends Setup__SetupConnectionRepository {
 }
 
 class SetupPolymorphicAggregateParentRelationshipRepository extends Setup__SetupPolymorphicAggregateParentRelationshipRepository {
-    getTypeDiscriminator(data, _selections) {
+    getTypeDiscriminator(_data, _selections) {
         // Hardcoded to Setup__SetupRecordAggregate since that's the only type of parent
         // relationship possible
         return 'Setup__SetupRecordAggregate';
@@ -105919,7 +106016,7 @@ class SetupPolymorphicAggregateParentRelationshipRepository extends Setup__Setup
 }
 
 class SetupPolymorphicParentRelationshipRepository extends Setup__SetupPolymorphicParentRelationshipRepository {
-    getTypeDiscriminator(data, _selections) {
+    getTypeDiscriminator(_data, _selections) {
         // Hardcoded to Setup__EntityRepresentation since that's the only type of parent
         // relationship possible
         return 'Setup__EntityRepresentation';
@@ -106060,6 +106157,7 @@ function deepMerge$1(data, extensions) {
     const dataType = typeof data;
     const extensionsType = typeof extensions;
     if (dataType === 'function' || extensionsType === 'function') {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
         throw new Error('Cannot merge functions');
     }
     if (dataType === 'undefined' || data === undefined) {
@@ -106400,7 +106498,9 @@ function buildCommandClass(baseClass) {
                     });
                     this.unsubscribers.push(unsubscribeFromLuvioSnapshot);
                 }
-                catch (error) { }
+                catch (error) {
+                    // intentionally do nothing
+                }
             }
         }
         usedRecordsChanged() {
@@ -106440,6 +106540,7 @@ function buildCommandClass(baseClass) {
     };
 }
 
+const REFRESH_FAILED_MESSAGE = 'Failed to refresh GraphQL data';
 function validateNonQueryGraphQLConfig(config) {
     if (config !== null && typeof config === 'object') {
         if (hasOwnProperty$1.call(config, 'operationName') &&
@@ -106506,6 +106607,7 @@ function defaultCheckConfig(config, requiredKeys, optionalKeys) {
     const invalidKeys = configKeys.filter((key) => !allowedKeysSet.includes(key));
     if (invalidKeys.length > 0) {
         // invalid keys, so set error state
+        // eslint-disable-next-line no-throw-literal
         throw {
             error: `Invalid config keys: ${invalidKeys.join(', ')}`,
             errorType: 'adapterError',
@@ -106555,6 +106657,7 @@ function createStateManager(getCommand, requiredConfigKeys, optionalConfigKeys =
         let processScheduled = false;
         let processingInitialConfig = false;
         let unsubscribe;
+        let currentResultRefresh;
         const statusAtom = atom('unconfigured');
         const errorsAtom = atom(undefined);
         const dataAtom = atom(undefined);
@@ -106564,7 +106667,7 @@ function createStateManager(getCommand, requiredConfigKeys, optionalConfigKeys =
             setAtom(errorsAtom, errors);
             setAtom(dataAtom, data);
         };
-        const refreshCallback = (refreshResult) => {
+        const subscribeCallback = (refreshResult) => {
             if (refreshResult.isOk()) {
                 resultCallback({
                     ok: true,
@@ -106593,12 +106696,13 @@ function createStateManager(getCommand, requiredConfigKeys, optionalConfigKeys =
                 .then((result) => {
                 // handle the initial result
                 if (result.isOk()) {
+                    currentResultRefresh = result.value.refresh.bind(result.value);
                     resultCallback({
                         ok: true,
                         data: result.value.data.data,
                         errors: undefined,
                     });
-                    unsubscribe = createWeakSubscription((cb) => result.value.subscribe(cb), new WeakRef(refreshCallback));
+                    unsubscribe = createWeakSubscription((cb) => result.value.subscribe(cb), new WeakRef(subscribeCallback));
                 }
                 else {
                     const resp = toGraphQLResponseFromFailure(result.error.failure);
@@ -106611,6 +106715,7 @@ function createStateManager(getCommand, requiredConfigKeys, optionalConfigKeys =
             });
         };
         const queueConfigUpdate = (config) => {
+            currentResultRefresh = undefined;
             try {
                 const configIsGood = _checkConfig(config);
                 queuedConfig = configIsGood ? config : undefined;
@@ -106637,6 +106742,23 @@ function createStateManager(getCommand, requiredConfigKeys, optionalConfigKeys =
             }
         };
         const setters = createSetters(allowedKeys, queueConfigUpdate);
+        const refresh = () => {
+            const status = statusAtom.value;
+            if (status === 'unconfigured' || status === 'error' || status === 'loading') {
+                return Promise.reject(new Error(REFRESH_FAILED_MESSAGE));
+            }
+            // status === 'loaded'
+            return new Promise((resolve, reject) => {
+                currentResultRefresh().then((res) => {
+                    if (res.isOk()) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(REFRESH_FAILED_MESSAGE));
+                    }
+                }, reject);
+            });
+        };
         if (initialConfig) {
             try {
                 processingInitialConfig = true;
@@ -106650,6 +106772,7 @@ function createStateManager(getCommand, requiredConfigKeys, optionalConfigKeys =
             status: statusAtom,
             errors: errorsAtom,
             data: dataAtom,
+            refresh,
             ...setters,
         };
     }, {
@@ -106870,7 +106993,7 @@ getServices(serviceRequirements).then((services) => {
         _(config, CONFIG_SCHEMA);
         const baseCommand = new graphql_imperative_ctor(config, documentRootType, services);
         return applyDecorators(baseCommand, [services.fetchNetworkCommandBaseClass.availableDecorators.abortable], options);
-    }, false);
+    }, true);
     graphql_imperative_legacy = services.graphQLLegacyImperativeBindings.bind(({ config, assertIsValid }) => {
         const _ = assertIsValid;
         _(config, CONFIG_SCHEMA);
@@ -106880,6 +107003,7 @@ getServices(serviceRequirements).then((services) => {
         services.graphQLLegacyImperativeBindings.bind(({ config, assertIsValid }) => {
             const validatedConfig = validateNonQueryGraphQLConfig(config);
             if (validatedConfig.isErr()) {
+                // eslint-disable-next-line @salesforce/lds/no-error-in-production
                 throw new Error(`Invalid configuration passed to GraphQL: ${validatedConfig.error}`);
             }
             const _ = assertIsValid;
@@ -106891,11 +107015,12 @@ getServices(serviceRequirements).then((services) => {
      */
     const graphql_state_manager_ctor = services.instrumentCommand(buildCommandClass(services.auraGraphQLNormalizedCacheControlCommand), 'graphql_state_manager');
     const factory = (config) => {
-        assertIsValid(config, CONFIG_SCHEMA);
+        assertIsValid$1(config, CONFIG_SCHEMA);
         const validatedConfig = resolveAndValidateGraphQLConfig(config, {
             acceptedOperations: ['query'],
         });
         if (validatedConfig === undefined || validatedConfig.isErr()) {
+            // eslint-disable-next-line @salesforce/lds/no-error-in-production
             throw new Error('Internal error in GraphQL adapter occurred: Unable to resolve query');
         }
         return new graphql_state_manager_ctor(validatedConfig.value, documentRootType, services);
@@ -106923,7 +107048,7 @@ function registerCallback(cb) {
         cb(graphql_v1_import, graphql_imperative$1, graphql_imperative_legacy_v1_import, graphql_state_manager, useOneStoreGraphQL);
     }
 }
-// version: 1.433.0-db129b48d2
+// version: 1.435.0-615ebb9bbd
 
 function createFragmentMap(documentNode) {
     const fragments = {};
@@ -134952,28 +135077,23 @@ let configurableCreateContentVersion$1 = new Configurable$1();
  * Depth to which tracked fields will be added to a request that results from a cache miss.
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMiss$1 = 5;
+let trackedFieldDepthOnCacheMiss$1 = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a merge conflict
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMergeConflict$1 = 5;
+let trackedFieldDepthOnCacheMergeConflict$1 = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a notify change invocation by the consumer
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnNotifyChange$1 = 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$1 = false;
+let trackedFieldDepthOnNotifyChange$1 = 1;
 /**
  * One store enabled Get Object Info adapter
  */
@@ -135070,12 +135190,6 @@ const configurationForRestAdapters$1 = {
     getTrackedFieldDepthOnNotifyChange: function () {
         return trackedFieldDepthOnNotifyChange$1;
     },
-    setTrackedFieldLeafNodeIdAndNameOnly: function (trackedFieldLeafNodeIdAndNameOnlyParam) {
-        trackedFieldLeafNodeIdAndNameOnly$1 = trackedFieldLeafNodeIdAndNameOnlyParam;
-    },
-    getTrackedFieldLeafNodeIdAndNameOnly: function () {
-        return trackedFieldLeafNodeIdAndNameOnly$1;
-    },
     setRecordRepresentationIngestionOverride: function (ingest) {
         recordRepresentationIngestionOverride$1 = ingest;
     },
@@ -135632,6 +135746,7 @@ withDefaultLuvio((luvio) => {
                 if (typeof data?.refresh === 'function') {
                     return data.refresh();
                 }
+                // eslint-disable-next-line @salesforce/lds/no-error-in-production
                 throw new Error('Component attempted to refresh a GraphQL result that is not refreshable');
             };
         }
@@ -136140,7 +136255,7 @@ register$1({
     configuration: { ...configurationForGraphQLAdapters$1 },
     instrument: instrument$1,
 });
-// version: 1.433.0-db129b48d2
+// version: 1.435.0-615ebb9bbd
 
 // On core the unstable adapters are re-exported with different names,
 // we want to match them here.
@@ -136292,7 +136407,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.433.0-db129b48d2
+// version: 1.435.0-615ebb9bbd
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -137091,7 +137206,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.433.0-8a15a98f24
+// version: 1.435.0-5818ce3c48
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -137127,28 +137242,23 @@ let configurableCreateContentVersion = new Configurable();
  * Depth to which tracked fields will be added to a request that results from a cache miss.
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMiss = 5;
+let trackedFieldDepthOnCacheMiss = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a merge conflict
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMergeConflict = 5;
+let trackedFieldDepthOnCacheMergeConflict = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a notify change invocation by the consumer
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
- */
-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
+ * @defaultValue '1'
  */
-let trackedFieldLeafNodeIdAndNameOnly = false;
+let trackedFieldDepthOnNotifyChange = 1;
 /**
  * One store enabled Get Object Info adapter
  */
@@ -137245,12 +137355,6 @@ const configurationForRestAdapters = {
     getTrackedFieldDepthOnNotifyChange: function () {
         return trackedFieldDepthOnNotifyChange;
     },
-    setTrackedFieldLeafNodeIdAndNameOnly: function (trackedFieldLeafNodeIdAndNameOnlyParam) {
-        trackedFieldLeafNodeIdAndNameOnly = trackedFieldLeafNodeIdAndNameOnlyParam;
-    },
-    getTrackedFieldLeafNodeIdAndNameOnly: function () {
-        return trackedFieldLeafNodeIdAndNameOnly;
-    },
     setRecordRepresentationIngestionOverride: function (ingest) {
         recordRepresentationIngestionOverride = ingest;
     },
@@ -138145,6 +138249,7 @@ function handleInstrumentation(activity, stat, progress) {
 const LUVIO_ADAPTER_FAMILY = /^force\/ldsAdapters/;
 async function importLuvioAdapterModule(specifier) {
     if (!LUVIO_ADAPTER_FAMILY.test(specifier)) {
+        // eslint-disable-next-line no-throw-literal
         throw `${specifier} is not an allowed luvio adapter module`;
     }
     let module;
@@ -138152,6 +138257,7 @@ async function importLuvioAdapterModule(specifier) {
         module = await import(specifier);
     }
     catch {
+        // eslint-disable-next-line no-throw-literal
         throw `module not found for specifier ${specifier}`;
     }
     return new LuvioAdapterModule(module);
@@ -138265,6 +138371,7 @@ function buildNativeResponse(response) {
 }
 async function importOneStoreAdapterModule(specifier) {
     if (!ONESTORE_ADAPTER_FAMILY.test(specifier)) {
+        // eslint-disable-next-line no-throw-literal
         throw `${specifier} is not an allowed onestore adapter module`;
     }
     let module;
@@ -138272,6 +138379,7 @@ async function importOneStoreAdapterModule(specifier) {
         module = await import(specifier);
     }
     catch {
+        // eslint-disable-next-line no-throw-literal
         throw `module not found for specifier ${specifier}`;
     }
     return new OneStoreAdapterModule(module);
@@ -138387,4 +138495,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, evictExpiredCacheEntries, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, importLuvioAdapterModule, importOneStoreAdapterModule, invokeAdapter, invokeAdapterWithDraftToMerge, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, stopEviction, subscribeToAdapter };
-// version: 1.433.0-8a15a98f24
+// version: 1.435.0-5818ce3c48