@salesforce/lds-worker-api 1.433.0 → 1.434.0

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

@@ -4280,7 +4280,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.433.0-8a15a98f24
+    // version: 1.434.0-d8deb0d4ea
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -5324,7 +5324,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.433.0-8a15a98f24
+    // version: 1.434.0-d8deb0d4ea
 
     function isSupportedEntity(_objectApiName) {
         return true;
@@ -5461,28 +5461,23 @@
      * 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
      */
@@ -5579,12 +5574,6 @@
         getTrackedFieldDepthOnNotifyChange: function () {
             return trackedFieldDepthOnNotifyChange$3;
         },
-        setTrackedFieldLeafNodeIdAndNameOnly: function (trackedFieldLeafNodeIdAndNameOnlyParam) {
-            trackedFieldLeafNodeIdAndNameOnly$3 = trackedFieldLeafNodeIdAndNameOnlyParam;
-        },
-        getTrackedFieldLeafNodeIdAndNameOnly: function () {
-            return trackedFieldLeafNodeIdAndNameOnly$3;
-        },
         setRecordRepresentationIngestionOverride: function (ingest) {
             recordRepresentationIngestionOverride$3 = ingest;
         },
@@ -5706,28 +5695,23 @@
      * 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
      */
@@ -5833,12 +5817,6 @@
         getTrackedFieldDepthOnNotifyChange: function () {
             return trackedFieldDepthOnNotifyChange$2;
         },
-        setTrackedFieldLeafNodeIdAndNameOnly: function (trackedFieldLeafNodeIdAndNameOnlyParam) {
-            trackedFieldLeafNodeIdAndNameOnly$2 = trackedFieldLeafNodeIdAndNameOnlyParam;
-        },
-        getTrackedFieldLeafNodeIdAndNameOnly: function () {
-            return trackedFieldLeafNodeIdAndNameOnly$2;
-        },
         setRecordRepresentationIngestionOverride: function (ingest) {
             recordRepresentationIngestionOverride$2 = ingest;
         },
@@ -7679,6 +7657,9 @@
         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 = {
@@ -7742,13 +7723,11 @@
                 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');
@@ -7770,19 +7749,10 @@
                     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) {
@@ -8168,7 +8138,6 @@
         };
         const trackedFieldsConfig = {
             maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMergeConflict(),
-            onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
         };
         extractTrackedFieldsToTrie$1(recordKey, incomingNode, incomingTrackedFieldsTrieRoot, trackedFieldsConfig);
         extractTrackedFieldsToTrie$1(recordKey, existingNode, existingTrackedFieldsTrieRoot, trackedFieldsConfig);
@@ -8612,7 +8581,6 @@
         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({
@@ -8739,7 +8707,6 @@
                 };
                 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,
@@ -13912,7 +13879,6 @@
                     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;
@@ -16501,7 +16467,6 @@
         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;
@@ -30545,7 +30510,6 @@
                     ...resourceRequest.queryParams,
                     optionalFields: getTrackedFields$1(templateRecordKey, luvio.getNode(templateRecordKey), {
                         maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-                        onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
                     }, config.optionalFields),
                 },
             });
@@ -31080,7 +31044,6 @@
                 ...resourceRequest.queryParams,
                 optionalFields: getTrackedFields$1(recordTemplateKey, luvio.getNode(recordTemplateKey), {
                     maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-                    onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
                 }, config.optionalFields),
             },
         });
@@ -31100,7 +31063,6 @@
         });
         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({
@@ -32556,7 +32518,7 @@
         throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
         throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
     });
-    // version: 1.433.0-db129b48d2
+    // version: 1.434.0-6aa2dd15e3
 
     var allowUpdatesForNonCachedRecords = {
         isOpen: function (e) {
@@ -44206,7 +44168,7 @@
     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;
       }
@@ -44217,7 +44179,7 @@
         return !this.isOk();
       }
     };
-    let Err$4 = class Err {
+    let Err$3 = class Err {
       constructor(error) {
         this.error = error;
       }
@@ -44228,8 +44190,8 @@
         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);
@@ -44372,6 +44334,15 @@
       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.,
@@ -44471,20 +44442,20 @@
         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,
@@ -44492,7 +44463,7 @@
             }
           ]);
         }
-        return ok$4(void 0);
+        return ok$3(void 0);
       }
       query(cache, query) {
         return this.read(cache, {
@@ -44510,12 +44481,12 @@
         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);
@@ -44538,9 +44509,375 @@
     }
     function buildReadWriteResult(data, errors) {
       if (errors.length > 0) {
-        return err$4(errors);
+        return err$3(errors);
       }
-      return ok$4(data);
+      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) {
+      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));
+      } else if ("oneOf" in schema) {
+        errorCollector.append(validateOneOf$1(data, schema, path, document));
+      } else if ("allOf" in schema) {
+        errorCollector.append(validateAllOf$1(data, schema, path, document));
+      } else if ("not" in schema) {
+        errorCollector.append(validateNot$1(data, schema, path, document));
+      } else if ("$ref" in schema) {
+        errorCollector.append(validateRef$1(data, schema, path, document));
+      } 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)
+            );
+          }
+        } else if (schema.type === "array") {
+          if (dataType !== "array") {
+            errorCollector.add(incorrectTypeError$1("array", dataType, path));
+          } else {
+            errorCollector.append(
+              validateArray$1(data, schema, path, document)
+            );
+          }
+        } 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) {
+      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 = validateJsonSchema$1(
+          data,
+          element,
+          `${path}.anyOf[${i}]`,
+          document
+        );
+        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) {
+      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 = validateJsonSchema$1(data, element, oneOfPath, document);
+        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 validateAllOf$1(data, schema, path, document) {
+      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 = validateJsonSchema$1(
+          data,
+          element,
+          `${path}.allOf[${i}]`,
+          document
+        );
+        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) {
+      const validationResponse = validateJsonSchema$1(data, schema.not, path, document);
+      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) {
+      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(
+            validateJsonSchema$1(
+              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$1(
+              `Object at path '${path}' is missing required property '${key}'.`
+            )
+          );
+        }
+        if (keyInData) {
+          errorCollector.append(
+            validateJsonSchema$1(
+              data[key],
+              schema.properties[key],
+              `${path}.${key}`,
+              document
+            )
+          );
+        }
+      }
+      return errorCollector.toValidationResponse();
+    }
+    function validateArray$1(data, schema, path, document) {
+      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(
+          validateJsonSchema$1(element, schema.items, `${path}[${index}]`, document)
+        )
+      );
+      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) {
+      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 '#')`
+          )
+        );
+      }
+      try {
+        const schemaToValidate = findSchemaAtPath$1(document, schema.$ref);
+        return validateJsonSchema$1(data, schemaToValidate, path, document);
+      } catch (e) {
+        return invalidSchemaResponseWithError$1(e);
+      }
+    }
+    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;
     }
 
     /*!
@@ -45387,35 +45724,6 @@
       }
       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
@@ -45466,6 +45774,14 @@
         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) {
@@ -51204,7 +51520,6 @@
         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({
@@ -51331,7 +51646,6 @@
                 };
                 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,
@@ -56301,7 +56615,6 @@
         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;
@@ -60173,7 +60486,6 @@
                     ...resourceRequest.queryParams,
                     optionalFields: getTrackedFields(templateRecordKey, luvio.getNode(templateRecordKey), {
                         maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-                        onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
                     }, config.optionalFields),
                 },
             });
@@ -60725,7 +61037,6 @@
                 ...resourceRequest.queryParams,
                 optionalFields: getTrackedFields(recordTemplateKey, luvio.getNode(recordTemplateKey), {
                     maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-                    onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
                 }, config.optionalFields),
             },
         });
@@ -60745,7 +61056,6 @@
         });
         const allTrackedFields = getTrackedFields(templateRecordKey, luvio.getNode(templateRecordKey), {
             maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-            onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
         }, optionalFields);
         const allTrackedFieldsTrie = convertFieldsToTrie(allTrackedFields, true);
         const ingest = createFieldsIngestSuccess({
@@ -80509,6 +80819,7 @@
         }
         async buildPendingAction(request, queue) {
             this.resolveResourceRequestBody(request.body);
+            // eslint-disable-next-line no-return-await
             return await super.buildPendingAction(request, queue);
         }
         resolveResourceRequestBody(body) {
@@ -80941,8 +81252,6 @@
         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.
@@ -87022,6 +87331,7 @@
         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);
@@ -88394,6 +88704,7 @@
         }
         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) {
@@ -90315,7 +90626,9 @@
                 }
                 instrumentation$2$1.trackValue(GRAPHQL_QUERY_ROOT_METRIC_NAME, row[1].length);
             }
-            catch { }
+            catch {
+                // intentionally do nothing
+            }
         }
     }
 
@@ -91024,6 +91337,7 @@
             const userData = {
                 ...stats,
             };
+            // eslint-disable-next-line guard-for-in
             for (const error in errors) {
                 activity.error(error);
             }
@@ -91204,6 +91518,7 @@
                 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)) {
@@ -93469,6 +93784,7 @@
         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) {
@@ -93683,7 +93999,7 @@
         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,
         });
@@ -96255,7 +96571,7 @@
             },
         };
     }
-    // version: 1.433.0-db129b48d2
+    // version: 1.434.0-6aa2dd15e3
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -96281,7 +96597,7 @@
             },
         };
     }
-    // version: 1.433.0-db129b48d2
+    // version: 1.434.0-6aa2dd15e3
 
     /*!
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -96686,26 +97002,26 @@
      * 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 = [];
       }
@@ -96726,100 +97042,100 @@
       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) {
+      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));
       } else if ("oneOf" in schema) {
-        errorCollector.append(validateOneOf$1(data, schema, path, document));
+        errorCollector.append(validateOneOf(data, schema, path, document));
       } else if ("allOf" in schema) {
-        errorCollector.append(validateAllOf$1(data, schema, path, document));
+        errorCollector.append(validateAllOf(data, schema, path, document));
       } else if ("not" in schema) {
-        errorCollector.append(validateNot$1(data, schema, path, document));
+        errorCollector.append(validateNot(data, schema, path, document));
       } else if ("$ref" in schema) {
-        errorCollector.append(validateRef$1(data, schema, path, document));
+        errorCollector.append(validateRef(data, schema, path, document));
       } 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)
             );
           }
         } 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)
             );
           }
         } 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) {
       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 = validateJsonSchema(
           data,
           element,
           `${path}.anyOf[${i}]`,
@@ -96834,19 +97150,19 @@
       }
       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) {
       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 = validateJsonSchema(data, element, oneOfPath, document);
         if (validationResponse.isOk()) {
           validSubShemaPaths.push(oneOfPath);
         } else {
@@ -96855,25 +97171,25 @@
       }
       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 validateAllOf$1(data, schema, path, document) {
+    function validateAllOf(data, schema, path, document) {
       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 = validateJsonSchema(
           data,
           element,
           `${path}.allOf[${i}]`,
@@ -96886,31 +97202,31 @@
       }
       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) {
+      const validationResponse = validateJsonSchema(data, schema.not, path, document);
       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) {
       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(
+            validateJsonSchema(
               data[key],
               schema.additionalProperties,
               `${path}.additionalProperties[${key}]`,
@@ -96924,14 +97240,14 @@
         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(
+            validateJsonSchema(
               data[key],
               schema.properties[key],
               `${path}.${key}`,
@@ -96942,95 +97258,95 @@
       }
       return errorCollector.toValidationResponse();
     }
-    function validateArray$1(data, schema, path, document) {
+    function validateArray(data, schema, path, document) {
       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)
+          validateJsonSchema(element, schema.items, `${path}[${index}]`, document)
         )
       );
       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) {
       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 '#')`
           )
         );
       }
       try {
-        const schemaToValidate = findSchemaAtPath$1(document, schema.$ref);
-        return validateJsonSchema$1(data, schemaToValidate, path, document);
+        const schemaToValidate = findSchemaAtPath(document, schema.$ref);
+        return validateJsonSchema(data, schemaToValidate, path, document);
       } catch (e) {
-        return invalidSchemaResponseWithError$1(e);
+        return invalidSchemaResponseWithError(e);
       }
     }
-    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;
@@ -97038,7 +97354,7 @@
       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}'`
           );
         }
@@ -97083,7 +97399,7 @@
      */
     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) {
@@ -97223,7 +97539,7 @@
     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);
@@ -97238,7 +97554,7 @@
           }
         };
         const subscribe = (config, requestContext, callback) => {
-          const command = getCommand({ config, assertIsValid: assertIsValid$1 });
+          const command = getCommand({ config, assertIsValid });
           let unsubscribe = () => {
           };
           try {
@@ -97297,13 +97613,7 @@
             }
             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);
           }
         };
       }
@@ -97397,8 +97707,8 @@
               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 = {
@@ -97415,13 +97725,7 @@
             }
             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) => {
@@ -97439,35 +97743,41 @@
               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();
           };
@@ -97501,7 +97811,7 @@
                 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);
@@ -97510,13 +97820,7 @@
               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);
           }
         };
       }
@@ -97584,8 +97888,8 @@
       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 {
@@ -97671,11 +97975,15 @@
         }
         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;
           }
         }
@@ -97728,6 +98036,16 @@
       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();
@@ -97820,16 +98138,14 @@
             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();
@@ -98481,9 +98797,11 @@
             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() {
@@ -98509,7 +98827,7 @@
                             });
                         });
                     }
-                    // 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);
@@ -98604,6 +98922,7 @@
         batchQuery(operations) {
             return new Promise((resolve, reject) => {
                 this.sqlStore.batchOperations(operations, (error) => {
+                    // eslint-disable-next-line no-unused-expressions
                     error ? reject(error) : resolve();
                 });
             });
@@ -98679,7 +98998,7 @@
             buildServiceDescriptor$7(),
             buildServiceDescriptor$1$1(),
             buildServiceDescriptor$2(),
-            // TODO[@W-18753648]: See note above.
+            // TODO [W-18753648]: See note above.
             // buildStreamingCommandServiceDescriptor(),
             // buildNdJsonServiceDescriptor(),
             // buildSseCommandServiceDescriptor(),
@@ -98938,378 +99257,12 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$2,
     });
-    // version: 1.433.0-8a15a98f24
+    // version: 1.434.0-d8deb0d4ea
 
     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.
@@ -99358,35 +99311,35 @@
     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)}`)
       );
     }
@@ -99429,10 +99382,10 @@
         (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) => {
@@ -99440,16 +99393,16 @@
           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;
@@ -99466,7 +99419,7 @@
         prev[fragment.name.value] = fragment;
         return prev;
       }, {});
-      return ok$4({
+      return ok$3({
         selections,
         request: { definitions: { variables, fragments } },
         parentFieldSelection: void 0
@@ -99624,13 +99577,13 @@
     }
     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}`
             )
@@ -99638,7 +99591,7 @@
         }
         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,
@@ -99663,17 +99616,17 @@
       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") {
@@ -99682,7 +99635,7 @@
             return ifResult;
           }
           if (ifResult.value === true) {
-            return ok$4(true);
+            return ok$3(true);
           }
         }
         if (directive.name.value === "include") {
@@ -99691,11 +99644,11 @@
             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) {
@@ -99703,11 +99656,11 @@
       }
       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(
@@ -99717,14 +99670,14 @@
             ]);
           }
         }
-        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;
@@ -99746,11 +99699,11 @@
       }
       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(
@@ -99759,10 +99712,10 @@
               }
             ]);
           }
-          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(
@@ -99790,18 +99743,18 @@
           }
         });
         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(
@@ -99810,10 +99763,10 @@
               }
             ]);
           }
-          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(
@@ -99838,9 +99791,9 @@
           }
         });
         if (arrayDenormalizationErrors.length > 0) {
-          return err$4(arrayDenormalizationErrors);
+          return err$3(arrayDenormalizationErrors);
         }
-        return ok$4(denormalizedArray);
+        return ok$3(denormalizedArray);
       }
     }
     class BaseObjectFieldDef {
@@ -99857,7 +99810,7 @@
       write(cache, input) {
         var _a;
         if (!input.selection.selectionSet) {
-          return err$4([
+          return err$3([
             {
               type: "unknown",
               error: new Error(
@@ -99867,11 +99820,11 @@
           ]);
         }
         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(
@@ -99880,7 +99833,7 @@
               }
             ]);
           }
-          return ok$4({ type: "data", data: null });
+          return ok$3({ type: "data", data: null });
         }
         const writeResult = this.repository.write(cache, {
           ...input,
@@ -99893,12 +99846,12 @@
         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(
@@ -99909,11 +99862,11 @@
         }
         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(
@@ -99922,7 +99875,7 @@
               }
             ]);
           }
-          return ok$4(null);
+          return ok$3(null);
         }
         return this.repository.read(cache, {
           ...input,
@@ -100205,7 +100158,7 @@
         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)}.`
             )
@@ -100216,10 +100169,10 @@
           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;
@@ -100325,22 +100278,22 @@
           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;
@@ -100399,7 +100352,7 @@
         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)) {
@@ -100408,7 +100361,7 @@
             metadata: this.cacheMetadata
           });
         }
-        return ok$4({
+        return ok$3({
           type: "link",
           linkedKey: key
         });
@@ -100423,7 +100376,7 @@
         if (normalizeDataResult.isErr()) {
           return normalizeDataResult;
         }
-        return ok$4(
+        return ok$3(
           deepMerge$2(
             {},
             (existingNormalizedData == null ? void 0 : existingNormalizedData.value) || {},
@@ -100493,7 +100446,7 @@
         if (result.isErr()) {
           return result;
         }
-        return ok$4({
+        return ok$3({
           data: result.value
         });
       }
@@ -100501,7 +100454,7 @@
         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(
@@ -100524,7 +100477,7 @@
           ...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) => {
@@ -100559,7 +100512,7 @@
       }
       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"`)
@@ -100569,7 +100522,7 @@
         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(
@@ -100580,7 +100533,7 @@
         }
         const selectionErr = this.verifyInterfaceFields(input.selections);
         if (selectionErr) {
-          return err$4(selectionErr);
+          return err$3(selectionErr);
         }
         const normalizeInput = {
           ...input,
@@ -100592,14 +100545,14 @@
         };
         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.`)
@@ -100609,7 +100562,7 @@
         const discriminator = unionRep.discriminator;
         const concreteRepository = this.possibleTypes[discriminator];
         if (!concreteRepository) {
-          return err$4([
+          return err$3([
             {
               type: "unknown",
               error: new Error(
@@ -100620,7 +100573,7 @@
         }
         const selectionErr = this.verifyInterfaceFields(input.selections);
         if (selectionErr) {
-          return err$4(selectionErr);
+          return err$3(selectionErr);
         }
         const denormalizeInput = {
           ...input,
@@ -100725,7 +100678,7 @@
       }
       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"`)
@@ -100735,7 +100688,7 @@
         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(
@@ -100746,7 +100699,7 @@
         }
         const selectionErr = this.verifyUnionFields(input.selections);
         if (selectionErr) {
-          return err$4(selectionErr);
+          return err$3(selectionErr);
         }
         const normalizeInput = {
           ...input,
@@ -100758,14 +100711,14 @@
         };
         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.`)
@@ -100775,7 +100728,7 @@
         const discriminator = unionRep.discriminator;
         const concreteRepository = this.possibleTypes[discriminator];
         if (!concreteRepository) {
-          return err$4([
+          return err$3([
             {
               type: "unknown",
               error: new Error(
@@ -100786,7 +100739,7 @@
         }
         const selectionErr = this.verifyUnionFields(input.selections);
         if (selectionErr) {
-          return err$4(selectionErr);
+          return err$3(selectionErr);
         }
         const denormalizeInput = {
           ...input,
@@ -105305,7 +105258,7 @@
      * @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) {
@@ -105773,7 +105726,7 @@
     }
 
     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';
@@ -105813,7 +105766,7 @@
     }
 
     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';
@@ -105870,6 +105823,7 @@
             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: [
@@ -105917,7 +105871,7 @@
     }
 
     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';
@@ -105925,7 +105879,7 @@
     }
 
     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';
@@ -106066,6 +106020,7 @@
         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) {
@@ -106406,7 +106361,9 @@
                         });
                         this.unsubscribers.push(unsubscribeFromLuvioSnapshot);
                     }
-                    catch (error) { }
+                    catch (error) {
+                        // intentionally do nothing
+                    }
                 }
             }
             usedRecordsChanged() {
@@ -106512,6 +106469,7 @@
         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',
@@ -106876,7 +106834,7 @@
             _(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);
@@ -106886,6 +106844,7 @@
             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;
@@ -106897,11 +106856,12 @@
          */
         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);
@@ -106929,7 +106889,7 @@
             cb(graphql_v1_import, graphql_imperative$1, graphql_imperative_legacy_v1_import, graphql_state_manager, useOneStoreGraphQL);
         }
     }
-    // version: 1.433.0-db129b48d2
+    // version: 1.434.0-6aa2dd15e3
 
     function createFragmentMap(documentNode) {
         const fragments = {};
@@ -134958,28 +134918,23 @@
      * 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
      */
@@ -135076,12 +135031,6 @@
         getTrackedFieldDepthOnNotifyChange: function () {
             return trackedFieldDepthOnNotifyChange$1;
         },
-        setTrackedFieldLeafNodeIdAndNameOnly: function (trackedFieldLeafNodeIdAndNameOnlyParam) {
-            trackedFieldLeafNodeIdAndNameOnly$1 = trackedFieldLeafNodeIdAndNameOnlyParam;
-        },
-        getTrackedFieldLeafNodeIdAndNameOnly: function () {
-            return trackedFieldLeafNodeIdAndNameOnly$1;
-        },
         setRecordRepresentationIngestionOverride: function (ingest) {
             recordRepresentationIngestionOverride$1 = ingest;
         },
@@ -135638,6 +135587,7 @@
                     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');
                 };
             }
@@ -136146,7 +136096,7 @@
         configuration: { ...configurationForGraphQLAdapters$1 },
         instrument: instrument$1,
     });
-    // version: 1.433.0-db129b48d2
+    // version: 1.434.0-6aa2dd15e3
 
     // On core the unstable adapters are re-exported with different names,
     // we want to match them here.
@@ -136298,7 +136248,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.433.0-db129b48d2
+    // version: 1.434.0-6aa2dd15e3
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -137097,7 +137047,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.433.0-8a15a98f24
+    // version: 1.434.0-d8deb0d4ea
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -137133,28 +137083,23 @@
      * 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
      */
@@ -137251,12 +137196,6 @@
         getTrackedFieldDepthOnNotifyChange: function () {
             return trackedFieldDepthOnNotifyChange;
         },
-        setTrackedFieldLeafNodeIdAndNameOnly: function (trackedFieldLeafNodeIdAndNameOnlyParam) {
-            trackedFieldLeafNodeIdAndNameOnly = trackedFieldLeafNodeIdAndNameOnlyParam;
-        },
-        getTrackedFieldLeafNodeIdAndNameOnly: function () {
-            return trackedFieldLeafNodeIdAndNameOnly;
-        },
         setRecordRepresentationIngestionOverride: function (ingest) {
             recordRepresentationIngestionOverride = ingest;
         },
@@ -138151,6 +138090,7 @@
     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;
@@ -138158,6 +138098,7 @@
             module = await import(specifier);
         }
         catch {
+            // eslint-disable-next-line no-throw-literal
             throw `module not found for specifier ${specifier}`;
         }
         return new LuvioAdapterModule(module);
@@ -138271,6 +138212,7 @@
     }
     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;
@@ -138278,6 +138220,7 @@
             module = await import(specifier);
         }
         catch {
+            // eslint-disable-next-line no-throw-literal
             throw `module not found for specifier ${specifier}`;
         }
         return new OneStoreAdapterModule(module);
@@ -138414,4 +138357,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.433.0-8a15a98f24
+// version: 1.434.0-d8deb0d4ea