@salesforce/lds-worker-api 1.432.0 → 1.434.0

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

@@ -4274,7 +4274,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.432.0-a57c62b660
+// version: 1.434.0-d8deb0d4ea
 
 // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
 function instrumentAdapter$1(createFunction, _metadata) {
@@ -5318,7 +5318,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     const { apiFamily, name } = metadata;
     return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
-// version: 1.432.0-a57c62b660
+// version: 1.434.0-d8deb0d4ea
 
 function isSupportedEntity(_objectApiName) {
     return true;
@@ -5455,28 +5455,23 @@ let configurableCreateContentVersion$3 = new Configurable$3();
  * Depth to which tracked fields will be added to a request that results from a cache miss.
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMiss$3 = 5;
+let trackedFieldDepthOnCacheMiss$3 = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a merge conflict
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMergeConflict$3 = 5;
+let trackedFieldDepthOnCacheMergeConflict$3 = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a notify change invocation by the consumer
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnNotifyChange$3 = 5;
-/**
- * Determines if we will only fetch the 'Id' field for the leaf relationship record
- * @defaultValue 'false', replicates the current behavior and fetches all fields in the store for the leaf relationship record
- */
-let trackedFieldLeafNodeIdAndNameOnly$3 = false;
+let trackedFieldDepthOnNotifyChange$3 = 1;
 /**
  * One store enabled Get Object Info adapter
  */
@@ -5573,12 +5568,6 @@ const configurationForEnvironmentFactoryOverrides$3 = {
     getTrackedFieldDepthOnNotifyChange: function () {
         return trackedFieldDepthOnNotifyChange$3;
     },
-    setTrackedFieldLeafNodeIdAndNameOnly: function (trackedFieldLeafNodeIdAndNameOnlyParam) {
-        trackedFieldLeafNodeIdAndNameOnly$3 = trackedFieldLeafNodeIdAndNameOnlyParam;
-    },
-    getTrackedFieldLeafNodeIdAndNameOnly: function () {
-        return trackedFieldLeafNodeIdAndNameOnly$3;
-    },
     setRecordRepresentationIngestionOverride: function (ingest) {
         recordRepresentationIngestionOverride$3 = ingest;
     },
@@ -5700,28 +5689,23 @@ let configurableCreateContentVersion$2 = new Configurable$2();
  * Depth to which tracked fields will be added to a request that results from a cache miss.
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMiss$2 = 5;
+let trackedFieldDepthOnCacheMiss$2 = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a merge conflict
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMergeConflict$2 = 5;
+let trackedFieldDepthOnCacheMergeConflict$2 = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a notify change invocation by the consumer
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnNotifyChange$2 = 5;
-/**
- * Determines if we will only fetch the 'Id' field for the leaf relationship record
- * @defaultValue 'false', replicates the current behavior and fetches all fields in the store for the leaf relationship record
- */
-let trackedFieldLeafNodeIdAndNameOnly$2 = false;
+let trackedFieldDepthOnNotifyChange$2 = 1;
 /**
  * One store enabled Get Object Info adapter
  */
@@ -5827,12 +5811,6 @@ const configurationForRestAdapters$2 = {
     getTrackedFieldDepthOnNotifyChange: function () {
         return trackedFieldDepthOnNotifyChange$2;
     },
-    setTrackedFieldLeafNodeIdAndNameOnly: function (trackedFieldLeafNodeIdAndNameOnlyParam) {
-        trackedFieldLeafNodeIdAndNameOnly$2 = trackedFieldLeafNodeIdAndNameOnlyParam;
-    },
-    getTrackedFieldLeafNodeIdAndNameOnly: function () {
-        return trackedFieldLeafNodeIdAndNameOnly$2;
-    },
     setRecordRepresentationIngestionOverride: function (ingest) {
         recordRepresentationIngestionOverride$2 = ingest;
     },
@@ -7673,6 +7651,9 @@ function buildSelectionFromRecord$1(record) {
     return [...sel.selections, DRAFTS_SELECTION$1];
 }
 
+// Unused suffixes, but leaving in as comments to avoid eslint errors
+// const CUSTOM_API_NAME_SUFFIX = '__c';
+// const DMO_API_NAME_SUFFIX = '__dlm';
 const CUSTOM_EXTERNAL_OBJECT_FIELD_SUFFIX$1 = '__x';
 const RECORD_REPRESENTATION_ERROR_VERSION$1 = 'RECORD_REPRESENTATION_ERROR_VERSION_1';
 const RECORD_REPRESENTATION_ERROR_STORE_METADATA_PARAMS$1 = {
@@ -7736,13 +7717,11 @@ function extractTrackedFieldsToTrie$1(recordId, node, root, config, visitedRecor
             if (!isGraphNode$1(field)) {
                 continue;
             }
-            const { maxDepth, onlyFetchLeafNodeIdAndName } = config;
+            const { maxDepth } = config;
             if (field.isScalar('value') === false && !Array.isArray(field.data?.value)) {
                 if (depth + 1 > maxDepth) {
-                    if (onlyFetchLeafNodeIdAndName === true) {
-                        addScalarFieldId$1(current);
-                        addScalarFieldName$1(current);
-                    }
+                    addScalarFieldId$1(current);
+                    addScalarFieldName$1(current);
                     continue;
                 }
                 const spanningLink = field.link('value');
@@ -7764,19 +7743,10 @@ function extractTrackedFieldsToTrie$1(recordId, node, root, config, visitedRecor
                 current.children[key] = next;
             }
             else {
-                // Skip the field, if its value is null at the max level depth.
-                // Ideally, it should only skip relationship field. However,
-                // on the client, there is not a reliable way to determine the
-                // the field type.
                 if (depth === maxDepth) {
-                    if (onlyFetchLeafNodeIdAndName === true) {
-                        addScalarFieldId$1(current);
-                        addScalarFieldName$1(current);
-                        continue;
-                    }
-                    if (field.scalar('value') === null && !Array.isArray(field.data?.value)) {
-                        continue;
-                    }
+                    addScalarFieldId$1(current);
+                    addScalarFieldName$1(current);
+                    continue;
                 }
                 const state = fieldValueRep.linkData();
                 if (state !== undefined) {
@@ -8162,7 +8132,6 @@ function mergeRecordConflict$1(luvio, incoming, existing, recordConflictMap) {
     };
     const trackedFieldsConfig = {
         maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMergeConflict(),
-        onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
     };
     extractTrackedFieldsToTrie$1(recordKey, incomingNode, incomingTrackedFieldsTrieRoot, trackedFieldsConfig);
     extractTrackedFieldsToTrie$1(recordKey, existingNode, existingTrackedFieldsTrieRoot, trackedFieldsConfig);
@@ -8606,7 +8575,6 @@ function prepareRequest$7(luvio, config) {
     const key = keyBuilder$28(luvio, createResourceParams$12(config));
     const allTrackedFields = getTrackedFields$1(key, luvio.getNode(key), {
         maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-        onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
     }, config.optionalFields);
     const optionalFields = fields === undefined ? allTrackedFields : difference$1(allTrackedFields, fields);
     const resourceParams = createResourceParams$12({
@@ -8733,7 +8701,6 @@ function ingestSuccessChildResourceParams$8(luvio, childResourceParamsArray, chi
             };
             const childTrackedFields = getTrackedFields$1(childKey, luvio.getNode(childKey), {
                 maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-                onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
             }, childResourceParams.queryParams.optionalFields);
             const childSnapshot = ingestSuccess$S(luvio, {
                 recordId: childResourceParams.urlParams.recordId,
@@ -13906,7 +13873,6 @@ const notifyChangeFactory = (luvio) => {
                 const node = luvio.wrapNormalizedGraphNode(record, key);
                 const optionalFields = getTrackedFields$1(key, node, {
                     maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnNotifyChange(),
-                    onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
                 });
                 const refreshRequest = createResourceRequestFromRepresentation(record, optionalFields);
                 const existingWeakEtag = record.weakEtag;
@@ -16495,7 +16461,6 @@ function buildNetworkSnapshot$V(luvio, config, options) {
     const key = keyBuilder$1w$2(luvio, config);
     const trackedFieldsConfig = {
         maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-        onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly()
     };
     const optionalFieldsTrie = convertFieldsToTrie$1(getTrackedFields$1(key, luvio.getNode(key), trackedFieldsConfig, config.optionalFields));
     const fieldsTrie = BLANK_RECORD_FIELDS_TRIE$1;
@@ -30539,7 +30504,6 @@ const buildNetworkSnapshot$6$1 = (luvio, context, config, options) => {
                 ...resourceRequest.queryParams,
                 optionalFields: getTrackedFields$1(templateRecordKey, luvio.getNode(templateRecordKey), {
                     maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-                    onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
                 }, config.optionalFields),
             },
         });
@@ -31074,7 +31038,6 @@ function prepareRequest$8(luvio, context, config) {
             ...resourceRequest.queryParams,
             optionalFields: getTrackedFields$1(recordTemplateKey, luvio.getNode(recordTemplateKey), {
                 maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-                onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
             }, config.optionalFields),
         },
     });
@@ -31094,7 +31057,6 @@ function onFetchResponseSuccess$O(luvio, context, config, request, response, res
     });
     const allTrackedFields = getTrackedFields$1(templateRecordKey, luvio.getNode(templateRecordKey), {
         maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-        onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
     }, optionalFields);
     const allTrackedFieldsTrie = convertFieldsToTrie$1(allTrackedFields, true);
     const ingest = createFieldsIngestSuccess$4({
@@ -32550,7 +32512,7 @@ withDefaultLuvio((luvio) => {
     throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
     throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
 });
-// version: 1.432.0-b99ba9d219
+// version: 1.434.0-6aa2dd15e3
 
 var allowUpdatesForNonCachedRecords = {
     isOpen: function (e) {
@@ -44200,7 +44162,7 @@ const { create: create$7, freeze: freeze$4, keys: keys$8, entries: entries$5 } =
 const { hasOwnProperty: hasOwnProperty$3 } = Object.prototype;
 const { isArray: isArray$7 } = Array;
 const { stringify: stringify$9, parse: parse$9 } = JSON;
-let Ok$4 = class Ok {
+let Ok$3 = class Ok {
   constructor(value) {
     this.value = value;
   }
@@ -44211,7 +44173,7 @@ let Ok$4 = class Ok {
     return !this.isOk();
   }
 };
-let Err$4 = class Err {
+let Err$3 = class Err {
   constructor(error) {
     this.error = error;
   }
@@ -44222,8 +44184,8 @@ let Err$4 = class Err {
     return !this.isOk();
   }
 };
-const ok$4 = (value) => new Ok$4(value);
-const err$4 = (err2) => new Err$4(err2);
+const ok$3 = (value) => new Ok$3(value);
+const err$3 = (err2) => new Err$3(err2);
 function resolvedPromiseLike$4(result) {
   if (isPromiseLike$4(result)) {
     return result.then((nextResult) => nextResult);
@@ -44366,6 +44328,15 @@ function satisfies(provided, requested) {
   const requestedN = requested.split(".").map((s) => parseInt(s));
   return providedN[0] === requestedN[0] && providedN[1] >= requestedN[1];
 }
+function isUserVisibleError$3(error) {
+  return error instanceof Error && "type" in error && error.type === "user-visible";
+}
+function logError$2(error) {
+  if (isUserVisibleError$3(error)) {
+    return;
+  }
+  console.error("OneStore Command threw an error that we did not expect", error);
+}
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -44465,20 +44436,20 @@ class IdentifiableTypeRepository {
     const existingNormalizedData = (_a = cache.get(key)) == null ? void 0 : _a.value;
     const normalized = this.normalizeData(cache, { ...input, existingNormalizedData });
     if (normalized.isErr()) {
-      return err$4(normalized.error);
+      return err$3(normalized.error);
     }
     cache.set(key, {
       value: normalized.value,
       metadata: this.cacheMetadata
     });
-    return ok$4({
+    return ok$3({
       type: "link",
       linkedKey: key
     });
   }
   validateEntry(entry) {
     if (!isCacheEntryForType(entry, this)) {
-      return err$4([
+      return err$3([
         {
           type: "incorrectType",
           expectedType: this.typeName,
@@ -44486,7 +44457,7 @@ class IdentifiableTypeRepository {
         }
       ]);
     }
-    return ok$4(void 0);
+    return ok$3(void 0);
   }
   query(cache, query) {
     return this.read(cache, {
@@ -44504,12 +44475,12 @@ class IdentifiableTypeRepository {
     if (cacheEntry) {
       const validationResult = this.validateEntry(cacheEntry);
       if (validationResult.isErr()) {
-        return err$4([...validationResult.error]);
+        return err$3([...validationResult.error]);
       }
       const normalizedData = cacheEntry.value;
       return this.denormalizeData(cache, { ...input, normalizedData });
     }
-    return err$4([this.buildMissingDataError()]);
+    return err$3([this.buildMissingDataError()]);
   }
   equals(x, y) {
     return deepEquals$2(x, y);
@@ -44532,9 +44503,375 @@ function extractReadWriteData(result, errorCollector) {
 }
 function buildReadWriteResult(data, errors) {
   if (errors.length > 0) {
-    return err$4(errors);
+    return err$3(errors);
+  }
+  return ok$3(data);
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+let JsonSchemaViolationError$1 = class JsonSchemaViolationError extends Error {
+  constructor(message, validationErrors) {
+    super(message);
+    this.validationErrors = [];
+    this.validationErrors = validationErrors || [];
+  }
+};
+let MinItemsViolationError$1 = class MinItemsViolationError extends JsonSchemaViolationError$1 {
+};
+let MaxItemsViolationError$1 = class MaxItemsViolationError extends JsonSchemaViolationError$1 {
+};
+let IncorrectTypeError$1 = class IncorrectTypeError extends JsonSchemaViolationError$1 {
+};
+let AdditionalPropertiesError$1 = class AdditionalPropertiesError extends JsonSchemaViolationError$1 {
+};
+let MissingRequiredPropertyError$1 = class MissingRequiredPropertyError extends JsonSchemaViolationError$1 {
+};
+let InvalidRefError$1 = class InvalidRefError extends JsonSchemaViolationError$1 {
+};
+let JsonSchemaErrorCollector$1 = class JsonSchemaErrorCollector {
+  constructor() {
+    this.errors = [];
+  }
+  add(error) {
+    this.errors.push(error);
+  }
+  append(response) {
+    if (response.isErr()) {
+      this.errors.push(...response.error);
+    }
+  }
+  hasErrors() {
+    return this.errors.length > 0;
+  }
+  prepend(error) {
+    this.errors.unshift(error);
+  }
+  toValidationResponse() {
+    return !this.hasErrors() ? ok$3(true) : err$3(this.errors);
+  }
+};
+function createThrowableError$1(errors) {
+  if (errors[0] instanceof MinItemsViolationError$1) {
+    return new MinItemsViolationError$1(errors[0].message, errors);
+  }
+  if (errors[0] instanceof MaxItemsViolationError$1) {
+    return new MaxItemsViolationError$1(errors[0].message, errors);
+  }
+  if (errors[0] instanceof IncorrectTypeError$1) {
+    return new IncorrectTypeError$1(errors[0].message, errors);
+  }
+  if (errors[0] instanceof AdditionalPropertiesError$1) {
+    return new AdditionalPropertiesError$1(errors[0].message, errors);
+  }
+  if (errors[0] instanceof MissingRequiredPropertyError$1) {
+    return new MissingRequiredPropertyError$1(errors[0].message, errors);
+  }
+  if (errors[0] instanceof InvalidRefError$1) {
+    return new InvalidRefError$1(errors[0].message, errors);
+  }
+  return new JsonSchemaViolationError$1(errors[0].message, errors);
+}
+function assertIsValid$1(data, schema) {
+  const validationResponse = validateJsonSchema$1(data, schema);
+  if (validationResponse.isErr()) {
+    throw createThrowableError$1(validationResponse.error);
+  }
+}
+function incorrectTypeError$1(expected, actual, path) {
+  return new IncorrectTypeError$1(
+    `Expected type ${expected} at path '${path}', found type ${actual}.`
+  );
+}
+function validSchemaResponse$1() {
+  return ok$3(true);
+}
+function invalidSchemaResponseWithError$1(error) {
+  return err$3([error]);
+}
+function validateJsonSchema$1(data, schema, path = "$", document = schema) {
+  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 ok$4(data);
+  return current;
 }
 
 /*!
@@ -45381,35 +45718,6 @@ const astResolver = function(astReference) {
   }
   return referenceMap.get(astReference);
 };
-/*!
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-let Ok$3 = class Ok {
-  constructor(value) {
-    this.value = value;
-  }
-  isOk() {
-    return true;
-  }
-  isErr() {
-    return !this.isOk();
-  }
-};
-let Err$3 = class Err {
-  constructor(error) {
-    this.error = error;
-  }
-  isOk() {
-    return false;
-  }
-  isErr() {
-    return !this.isOk();
-  }
-};
-const ok$3 = (value) => new Ok$3(value);
-const err$3 = (err2) => new Err$3(err2);
 function findExecutableOperation$2(document, operationName) {
   const operations = document.definitions.filter(
     (def) => def.kind === Kind$1.OPERATION_DEFINITION
@@ -45460,6 +45768,14 @@ function resolveAndValidateGraphQLConfig(config, options) {
     query: result.value
   });
 }
+function toGraphQLErrorResponse(error) {
+  logError$2(error);
+  const message = error instanceof JsonSchemaViolationError$1 ? `Invalid GraphQL config: ${error.message}` : "Internal error in GraphQL adapter occurred";
+  return {
+    data: void 0,
+    errors: [{ message, locations: [] }]
+  };
+}
 function resolveAndValidateGraphQLDocument(query, operationName, options) {
   const resolved = resolveAst(query);
   if (resolved === void 0) {
@@ -51198,7 +51514,6 @@ function prepareRequest$5(luvio, config) {
     const key = keyBuilder$1M(luvio, createResourceParams$g(config));
     const allTrackedFields = getTrackedFields(key, luvio.getNode(key), {
         maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-        onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
     }, config.optionalFields);
     const optionalFields = fields === undefined ? allTrackedFields : difference(allTrackedFields, fields);
     const resourceParams = createResourceParams$g({
@@ -51325,7 +51640,6 @@ function ingestSuccessChildResourceParams$2(luvio, childResourceParamsArray, chi
             };
             const childTrackedFields = getTrackedFields(childKey, luvio.getNode(childKey), {
                 maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-                onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
             }, childResourceParams.queryParams.optionalFields);
             const childSnapshot = ingestSuccess$8(luvio, {
                 recordId: childResourceParams.urlParams.recordId,
@@ -56295,7 +56609,6 @@ function buildNetworkSnapshot$c(luvio, config, options) {
     const key = keyBuilder$1w$1(luvio, config);
     const trackedFieldsConfig = {
         maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-        onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
     };
     const optionalFieldsTrie = convertFieldsToTrie(getTrackedFields(key, luvio.getNode(key), trackedFieldsConfig, config.optionalFields));
     const fieldsTrie = BLANK_RECORD_FIELDS_TRIE;
@@ -60167,7 +60480,6 @@ const buildNetworkSnapshot$3 = (luvio, context, config, options) => {
                 ...resourceRequest.queryParams,
                 optionalFields: getTrackedFields(templateRecordKey, luvio.getNode(templateRecordKey), {
                     maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-                    onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
                 }, config.optionalFields),
             },
         });
@@ -60719,7 +61031,6 @@ function prepareRequest(luvio, context, config) {
             ...resourceRequest.queryParams,
             optionalFields: getTrackedFields(recordTemplateKey, luvio.getNode(recordTemplateKey), {
                 maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-                onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
             }, config.optionalFields),
         },
     });
@@ -60739,7 +61050,6 @@ function onFetchResponseSuccess$2(luvio, context, config, request, response, res
     });
     const allTrackedFields = getTrackedFields(templateRecordKey, luvio.getNode(templateRecordKey), {
         maxDepth: configurationForRestAdapters$2.getTrackedFieldDepthOnCacheMiss(),
-        onlyFetchLeafNodeIdAndName: configurationForRestAdapters$2.getTrackedFieldLeafNodeIdAndNameOnly(),
     }, optionalFields);
     const allTrackedFieldsTrie = convertFieldsToTrie(allTrackedFields, true);
     const ingest = createFieldsIngestSuccess({
@@ -80503,6 +80813,7 @@ class AbstractQuickActionHandler extends AbstractResourceRequestActionHandler {
     }
     async buildPendingAction(request, queue) {
         this.resolveResourceRequestBody(request.body);
+        // eslint-disable-next-line no-return-await
         return await super.buildPendingAction(request, queue);
     }
     resolveResourceRequestBody(body) {
@@ -80935,8 +81246,6 @@ function isCreateContentDocumentAndVersionDraftAdapterEvent(customEvent) {
     return customEvent.namespace === CONTENT_DOCUMENT_AND_VERSION_NAMESPACE;
 }
 
-// so eslint doesn't complain about nimbus
-/* global __nimbus */
 function chunkToBase64(chunk) {
     const bytes = new Uint8Array(chunk);
     const CHUNK_SIZE = 64 * 1024; // 64kb, any bigger and fromCharCode() can error out with an overflow.
@@ -87016,6 +87325,7 @@ function isPolymorphicFieldPath(path, pathToObjectApiNamesMap, objectInfos) {
     const parentObjectInfo = objectInfos[parentObjectApiNames[0]];
     // this should not be undefined, but lets catch it if we do end up in that state.
     if (parentObjectInfo === undefined) {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
         throw new Error(`ObjectInfo is missing for ${parentObjectApiNames[0]} for ${parentApiPath}`);
     }
     const relationshipField = referenceIdFieldForRelationship(lastSegment);
@@ -88388,6 +88698,7 @@ function checkForEmptyData(gqlResult) {
     }
     const query = data.uiapi.query;
     // Check all entity types in the query for edges - using for...in to avoid array allocation
+    // eslint-disable-next-line guard-for-in
     for (const entityType in query) {
         const entity = query[entityType];
         if (entity && entity.edges && isArray$3$1(entity.edges) && entity.edges.length > 0) {
@@ -90309,7 +90620,9 @@ class NimbusSqliteStore {
             }
             instrumentation$2$1.trackValue(GRAPHQL_QUERY_ROOT_METRIC_NAME, row[1].length);
         }
-        catch { }
+        catch {
+            // intentionally do nothing
+        }
     }
 }
 
@@ -91018,6 +91331,7 @@ class PrimingSession extends EventEmitter {
         const userData = {
             ...stats,
         };
+        // eslint-disable-next-line guard-for-in
         for (const error in errors) {
             activity.error(error);
         }
@@ -91198,6 +91512,7 @@ class PrimingSession extends EventEmitter {
             let limitedResult = this.applyRetryLimits(result.additionalWork);
             this.enqueue(limitedResult.additionalWork);
             if (limitedResult.recordsNeedingRefetch.size > 0) {
+                // eslint-disable-next-line guard-for-in
                 for (const key in keys$3(limitedResult.recordsNeedingRefetch)) {
                     const value = limitedResult.recordsNeedingRefetch.get(key);
                     if (result.recordsNeedingRefetch.has(key)) {
@@ -93463,6 +93778,7 @@ class DurableRecordStore {
     async exists(key) {
         const result = await this.durableStore.query('SELECT EXISTS(SELECT 1 FROM lds_data WHERE key = ?)', [key]);
         const exists = result.rows[0][0];
+        // eslint-disable-next-line eqeqeq
         return exists == true;
     }
     async getRecord(key) {
@@ -93677,7 +93993,7 @@ var CounterResult;
     CounterResult["Error"] = "Error";
 })(CounterResult || (CounterResult = {}));
 function incrementCounter(name, result) {
-    instrumentation$4.incrementCounter('SFSSideEffect', 1, result == CounterResult.Error, {
+    instrumentation$4.incrementCounter('SFSSideEffect', 1, result === CounterResult.Error, {
         Name: name,
         Result: result,
     });
@@ -94090,16 +94406,17 @@ class AuraNetworkCommand extends NetworkCommand$1 {
       }
       return ok$1(auraReturnValue);
     }).catch((error) => {
-      if (!error || !error.getError) {
+      if (!error) {
         return err$1(toError("Failed to get error from response"));
-      } else {
-        const actionErrors = error.getError();
-        if (actionErrors.length > 0) {
-          return err$1(coerceError(actionErrors));
-        } else {
-          return err$1(toError("Error fetching component"));
-        }
       }
+      if (!error.getError) {
+        return err$1(toError(error));
+      }
+      const actionErrors = error.getError();
+      if (actionErrors.length > 0) {
+        return err$1(coerceError(actionErrors));
+      }
+      return err$1(toError("Error fetching component"));
     });
   }
   convertFetchResponseToData(response) {
@@ -94782,16 +95099,17 @@ let AuraCacheControlCommand$1 = class AuraCacheControlCommand extends CacheContr
       } catch {
       }
     }).catch((error) => {
-      if (!error || !error.getError) {
+      if (!error) {
         return err$1(toError("Failed to get error from response"));
-      } else {
-        const actionErrors = error.getError();
-        if (actionErrors.length > 0) {
-          return err$1(coerceError(actionErrors));
-        } else {
-          return err$1(toError("Error fetching component"));
-        }
       }
+      if (!error.getError) {
+        return err$1(toError(error));
+      }
+      const actionErrors = error.getError();
+      if (actionErrors.length > 0) {
+        return err$1(coerceError(actionErrors));
+      }
+      return err$1(toError("Error fetching component"));
     });
   }
   convertFetchResponseToData(response) {
@@ -94926,16 +95244,17 @@ class AuraCacheControlCommand extends CacheControlCommand {
       } catch {
       }
     }).catch((error) => {
-      if (!error || !error.getError) {
+      if (!error) {
         return err$1(toError("Failed to get error from response"));
-      } else {
-        const actionErrors = error.getError();
-        if (actionErrors.length > 0) {
-          return err$1(coerceError(actionErrors));
-        } else {
-          return err$1(toError("Error fetching component"));
-        }
       }
+      if (!error.getError) {
+        return err$1(toError(error));
+      }
+      const actionErrors = error.getError();
+      if (actionErrors.length > 0) {
+        return err$1(coerceError(actionErrors));
+      }
+      return err$1(toError("Error fetching component"));
     });
   }
   convertFetchResponseToData(response) {
@@ -96246,7 +96565,7 @@ function buildServiceDescriptor$b(luvio) {
         },
     };
 }
-// version: 1.432.0-b99ba9d219
+// version: 1.434.0-6aa2dd15e3
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -96272,7 +96591,7 @@ function buildServiceDescriptor$a(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.432.0-b99ba9d219
+// version: 1.434.0-6aa2dd15e3
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -96677,26 +96996,26 @@ function buildServiceDescriptor$8() {
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-let JsonSchemaViolationError$1 = class JsonSchemaViolationError extends Error {
+class JsonSchemaViolationError extends Error {
   constructor(message, validationErrors) {
     super(message);
     this.validationErrors = [];
     this.validationErrors = validationErrors || [];
   }
-};
-let MinItemsViolationError$1 = class MinItemsViolationError extends JsonSchemaViolationError$1 {
-};
-let MaxItemsViolationError$1 = class MaxItemsViolationError extends JsonSchemaViolationError$1 {
-};
-let IncorrectTypeError$1 = class IncorrectTypeError extends JsonSchemaViolationError$1 {
-};
-let AdditionalPropertiesError$1 = class AdditionalPropertiesError extends JsonSchemaViolationError$1 {
-};
-let MissingRequiredPropertyError$1 = class MissingRequiredPropertyError extends JsonSchemaViolationError$1 {
-};
-let InvalidRefError$1 = class InvalidRefError extends JsonSchemaViolationError$1 {
-};
-let JsonSchemaErrorCollector$1 = class JsonSchemaErrorCollector {
+}
+class MinItemsViolationError extends JsonSchemaViolationError {
+}
+class MaxItemsViolationError extends JsonSchemaViolationError {
+}
+class IncorrectTypeError extends JsonSchemaViolationError {
+}
+class AdditionalPropertiesError extends JsonSchemaViolationError {
+}
+class MissingRequiredPropertyError extends JsonSchemaViolationError {
+}
+class InvalidRefError extends JsonSchemaViolationError {
+}
+class JsonSchemaErrorCollector {
   constructor() {
     this.errors = [];
   }
@@ -96717,100 +97036,100 @@ let JsonSchemaErrorCollector$1 = class JsonSchemaErrorCollector {
   toValidationResponse() {
     return !this.hasErrors() ? ok$1(true) : err$1(this.errors);
   }
-};
-function createThrowableError$1(errors) {
-  if (errors[0] instanceof MinItemsViolationError$1) {
-    return new MinItemsViolationError$1(errors[0].message, errors);
+}
+function createThrowableError(errors) {
+  if (errors[0] instanceof MinItemsViolationError) {
+    return new MinItemsViolationError(errors[0].message, errors);
   }
-  if (errors[0] instanceof MaxItemsViolationError$1) {
-    return new MaxItemsViolationError$1(errors[0].message, errors);
+  if (errors[0] instanceof MaxItemsViolationError) {
+    return new MaxItemsViolationError(errors[0].message, errors);
   }
-  if (errors[0] instanceof IncorrectTypeError$1) {
-    return new IncorrectTypeError$1(errors[0].message, errors);
+  if (errors[0] instanceof IncorrectTypeError) {
+    return new IncorrectTypeError(errors[0].message, errors);
   }
-  if (errors[0] instanceof AdditionalPropertiesError$1) {
-    return new AdditionalPropertiesError$1(errors[0].message, errors);
+  if (errors[0] instanceof AdditionalPropertiesError) {
+    return new AdditionalPropertiesError(errors[0].message, errors);
   }
-  if (errors[0] instanceof MissingRequiredPropertyError$1) {
-    return new MissingRequiredPropertyError$1(errors[0].message, errors);
+  if (errors[0] instanceof MissingRequiredPropertyError) {
+    return new MissingRequiredPropertyError(errors[0].message, errors);
   }
-  if (errors[0] instanceof InvalidRefError$1) {
-    return new InvalidRefError$1(errors[0].message, errors);
+  if (errors[0] instanceof InvalidRefError) {
+    return new InvalidRefError(errors[0].message, errors);
   }
-  return new JsonSchemaViolationError$1(errors[0].message, errors);
+  return new JsonSchemaViolationError(errors[0].message, errors);
 }
-function assertIsValid$1(data, schema) {
-  const validationResponse = validateJsonSchema$1(data, schema);
+function assertIsValid(data, schema) {
+  const validationResponse = validateJsonSchema(data, schema);
   if (validationResponse.isErr()) {
-    throw createThrowableError$1(validationResponse.error);
+    throw createThrowableError(validationResponse.error);
   }
 }
-function incorrectTypeError$1(expected, actual, path) {
-  return new IncorrectTypeError$1(
+function incorrectTypeError(expected, actual, path) {
+  return new IncorrectTypeError(
     `Expected type ${expected} at path '${path}', found type ${actual}.`
   );
 }
-function validSchemaResponse$1() {
+function validSchemaResponse() {
   return ok$1(true);
 }
-function invalidSchemaResponseWithError$1(error) {
+function invalidSchemaResponseWithError(error) {
   return err$1([error]);
 }
-function validateJsonSchema$1(data, schema, path = "$", document = schema) {
-  if (schema === true) return validSchemaResponse$1();
+function validateJsonSchema(data, schema, path = "$", document = schema) {
+  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}]`,
@@ -96825,19 +97144,19 @@ function validateAnyOf$1(data, schema, path, document) {
   }
   if (!isValid) {
     errorCollector.prepend(
-      new JsonSchemaViolationError$1(`Data at ${path} did not match any subschema in anyOf.`)
+      new JsonSchemaViolationError(`Data at ${path} did not match any subschema in anyOf.`)
     );
     return errorCollector.toValidationResponse();
   }
-  return validSchemaResponse$1();
+  return validSchemaResponse();
 }
-function validateOneOf$1(data, schema, path, document) {
+function validateOneOf(data, schema, path, document) {
   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 {
@@ -96846,25 +97165,25 @@ function validateOneOf$1(data, schema, path, document) {
   }
   if (validSubShemaPaths.length === 0) {
     errorCollector.prepend(
-      new JsonSchemaViolationError$1(`Data at ${path} did not match any subschema in oneOf.`)
+      new JsonSchemaViolationError(`Data at ${path} did not match any subschema in oneOf.`)
     );
     return errorCollector.toValidationResponse();
   } else if (validSubShemaPaths.length > 1) {
     errorCollector.prepend(
-      new JsonSchemaViolationError$1(
+      new JsonSchemaViolationError(
         `Data at ${path} matched multiple subschemas: [${validSubShemaPaths.join(", ")}].`
       )
     );
     return errorCollector.toValidationResponse();
   }
-  return validSchemaResponse$1();
+  return validSchemaResponse();
 }
-function 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}]`,
@@ -96877,31 +97196,31 @@ function validateAllOf$1(data, schema, path, document) {
   }
   if (!isValid) {
     errorCollector.prepend(
-      new JsonSchemaViolationError$1(`Data at ${path} did not match some subschemas in allOf.`)
+      new JsonSchemaViolationError(`Data at ${path} did not match some subschemas in allOf.`)
     );
   }
   return errorCollector.toValidationResponse();
 }
-function validateNot$1(data, schema, path, document) {
-  const validationResponse = validateJsonSchema$1(data, schema.not, path, document);
+function validateNot(data, schema, path, document) {
+  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}]`,
@@ -96915,14 +97234,14 @@ function validateObject$1(data, schema, path, document) {
     const keyInData = key in data && data[key] !== void 0;
     if (requiredKeys.has(key) && !keyInData) {
       errorCollector.add(
-        new MissingRequiredPropertyError$1(
+        new MissingRequiredPropertyError(
           `Object at path '${path}' is missing required property '${key}'.`
         )
       );
     }
     if (keyInData) {
       errorCollector.append(
-        validateJsonSchema$1(
+        validateJsonSchema(
           data[key],
           schema.properties[key],
           `${path}.${key}`,
@@ -96933,95 +97252,95 @@ function validateObject$1(data, schema, path, document) {
   }
   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;
@@ -97029,7 +97348,7 @@ function findSchemaAtPath$1(document, ref) {
   for (const key of keys) {
     path = `${path}/${key}`;
     if (current[key] === void 0) {
-      throw new InvalidRefError$1(
+      throw new InvalidRefError(
         `Invalid $ref value '${ref}'. Cannot find target schema at '${path}'`
       );
     }
@@ -97074,7 +97393,7 @@ function logError(error) {
  */
 function buildBaseImperativeInvoker(getCommand, transformResult) {
   return async (...params) => {
-    const command = getCommand({ params, assertIsValid: assertIsValid$1 });
+    const command = getCommand({ params, assertIsValid });
     try {
       return command.execute().then((result) => transformResult(result));
     } catch (error) {
@@ -97214,7 +97533,7 @@ function buildServiceDescriptor$4() {
 class LegacyImperativeBindingsService {
   bind(getCommand) {
     const invoke = async (config, requestContext, callback) => {
-      const command = getCommand({ config, assertIsValid: assertIsValid$1 });
+      const command = getCommand({ config, assertIsValid });
       try {
         const overrides = getOverridesForLegacyRequestContext(requestContext);
         const result = await command.execute(overrides);
@@ -97229,7 +97548,7 @@ class LegacyImperativeBindingsService {
       }
     };
     const subscribe = (config, requestContext, callback) => {
-      const command = getCommand({ config, assertIsValid: assertIsValid$1 });
+      const command = getCommand({ config, assertIsValid });
       let unsubscribe = () => {
       };
       try {
@@ -97288,13 +97607,7 @@ class GraphQLImperativeBindingsService {
         }
         return await buildBaseImperativeInvoker(getCommand, (result) => this.transformResult(result, exposeRefresh))(...params);
       } catch (error) {
-        logError$1(error);
-        return {
-          data: void 0,
-          errors: [
-            { message: "Internal error in GraphQL adapter occurred", locations: [] }
-          ]
-        };
+        return toGraphQLErrorResponse(error);
       }
     };
   }
@@ -97388,8 +97701,8 @@ class GraphQLLegacyImperativeBindingsService {
           config = result.value;
         }
       }
-      const command = getCommand({ config, assertIsValid: assertIsValid$1 });
       try {
+        const command = getCommand({ config, assertIsValid });
         const overrides = getOverridesForLegacyRequestContext(requestContext);
         const result = await command.execute(overrides);
         const consumerEmittedData = {
@@ -97406,13 +97719,7 @@ class GraphQLLegacyImperativeBindingsService {
         }
         callback(consumerEmittedData);
       } catch (error) {
-        logError$1(error);
-        callback({
-          data: void 0,
-          errors: [
-            { message: "Internal error in GraphQL adapter occurred", locations: [] }
-          ]
-        });
+        callback(toGraphQLErrorResponse(error));
       }
     };
     const subscribe = (config, requestContext, callback) => {
@@ -97430,35 +97737,41 @@ class GraphQLLegacyImperativeBindingsService {
           config = result.value;
         }
       }
-      const command = getCommand({ config, assertIsValid: assertIsValid$1 });
       let unsubscribe = () => {
       };
-      const overrides = getOverridesForLegacyRequestContext(requestContext);
-      command.execute(overrides).then((result) => {
-        const consumerEmittedData = {
-          data: void 0,
-          errors: void 0
-        };
-        if (result.isOk()) {
-          deepFreeze(result.value);
-          consumerEmittedData.data = result.value.data.data;
-          unsubscribe = result.value.subscribe(
-            (res) => {
-              handleEmit(res, callback);
-            }
-          );
-        } else {
-          const { data, errors } = toGraphQLResponseFromFailure$1(result.error.failure);
-          consumerEmittedData.data = data;
-          consumerEmittedData.errors = errors;
-          unsubscribe = result.error.subscribe(
-            (res) => {
-              handleEmit(res, callback);
-            }
-          );
-        }
-        callback(consumerEmittedData);
-      });
+      try {
+        const command = getCommand({ config, assertIsValid });
+        const overrides = getOverridesForLegacyRequestContext(requestContext);
+        command.execute(overrides).then((result) => {
+          const consumerEmittedData = {
+            data: void 0,
+            errors: void 0
+          };
+          if (result.isOk()) {
+            deepFreeze(result.value);
+            consumerEmittedData.data = result.value.data.data;
+            unsubscribe = result.value.subscribe(
+              (res) => {
+                handleEmit(res, callback);
+              }
+            );
+          } else {
+            const { data, errors } = toGraphQLResponseFromFailure$1(
+              result.error.failure
+            );
+            consumerEmittedData.data = data;
+            consumerEmittedData.errors = errors;
+            unsubscribe = result.error.subscribe(
+              (res) => {
+                handleEmit(res, callback);
+              }
+            );
+          }
+          callback(consumerEmittedData);
+        });
+      } catch (error) {
+        callback(toGraphQLErrorResponse(error));
+      }
       return () => {
         unsubscribe();
       };
@@ -97492,7 +97805,7 @@ class GraphQLMutationBindingsService {
             params[0] = result2.value;
           }
         }
-        const command = getCommand({ params, assertIsValid: assertIsValid$1 });
+        const command = getCommand({ params, assertIsValid });
         const result = await command.execute({ cacheControlConfig: { type: "no-cache" } });
         if (result.isOk()) {
           deepFreeze(result.value);
@@ -97501,13 +97814,7 @@ class GraphQLMutationBindingsService {
           return toGraphQLResponseFromFailure$1(result.error.failure);
         }
       } catch (error) {
-        logError$1(error);
-        return {
-          data: void 0,
-          errors: [
-            { message: "Internal error in GraphQL adapter occurred", locations: [] }
-          ]
-        };
+        return toGraphQLErrorResponse(error);
       }
     };
   }
@@ -97575,8 +97882,8 @@ function sanitize(obj) {
   return new Sanitizer(obj).sanitize();
 }
 function isIncompleteConfigError(err) {
-  return err instanceof MissingRequiredPropertyError$1 || err instanceof JsonSchemaViolationError$1 && err.validationErrors.find(
-    (validationError) => validationError instanceof MissingRequiredPropertyError$1
+  return err instanceof MissingRequiredPropertyError || err instanceof JsonSchemaViolationError && err.validationErrors.find(
+    (validationError) => validationError instanceof MissingRequiredPropertyError
   ) !== void 0;
 }
 class CommandWireAdapterConstructor {
@@ -97662,11 +97969,15 @@ class CommandWireAdapterConstructor {
     }
     if (this.configSchema) {
       try {
-        assertIsValid$1(this.config, this.configSchema);
+        assertIsValid(this.config, this.configSchema);
       } catch (err) {
         if (isIncompleteConfigError(err)) {
           return;
         }
+        if (err instanceof JsonSchemaViolationError) {
+          this.handleConfigSchemaViolation(err);
+          return;
+        }
         throw err;
       }
     }
@@ -97719,6 +98030,16 @@ class CommandWireAdapterConstructor {
   handleExecutionThrow(error) {
     emitError(this.callback, error);
   }
+  /**
+   * Hook for subclasses to handle a JsonSchemaViolationError from the config
+   * schema assertion. The default re-throws so legacy non-GraphQL wire
+   * adapters keep their existing throw behavior. Overrides are expected to
+   * either emit an error result or re-throw — silently returning will
+   * swallow the error.
+   */
+  handleConfigSchemaViolation(error) {
+    throw error;
+  }
   unsubscribe() {
     if (this.unsubscriber) {
       this.unsubscriber();
@@ -97811,16 +98132,14 @@ class GraphQLCommandWireAdapterConstructor extends CommandWireAdapterConstructor
         this.callback(consumerEmittedData);
       }
     } catch (e) {
-      logError$1(e);
       this.handleExecutionThrow(e);
     }
   }
-  handleExecutionThrow(e) {
-    logError$1(e);
-    this.callback({
-      data: void 0,
-      errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
-    });
+  handleExecutionThrow(error) {
+    this.callback(toGraphQLErrorResponse(error));
+  }
+  handleConfigSchemaViolation(error) {
+    this.handleExecutionThrow(error);
   }
   update(config, _context) {
     this.unsubscribe();
@@ -98472,9 +98791,11 @@ class NimbusDurableCacheInclusionPolicy extends DurableCacheInclusionPolicy {
         return entries.length > 0 ? this.store.setEntries(entries) : Promise.resolve();
     }
     find(_query) {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
         throw new Error('find not supported on the NimbusDurableCacheInclusionPolicy');
     }
     findAndModify(_query, _cacheUpdate) {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
         throw new Error('findAndModify not supported on the NimbusDurableCacheInclusionPolicy');
     }
     registerListener() {
@@ -98500,7 +98821,7 @@ class NimbusDurableCacheInclusionPolicy extends DurableCacheInclusionPolicy {
                         });
                     });
                 }
-                // TODO: onestore doesnt support cache eviction yet
+                // TODO [W-19368859]: onestore doesnt support cache eviction yet
                 // if (evictKeys.size > 0) {
                 //     evictKeys.forEach((key) => {
                 //         this.services.cache.evict(key);
@@ -98595,6 +98916,7 @@ class NimbusSqliteOneStoreCache {
     batchQuery(operations) {
         return new Promise((resolve, reject) => {
             this.sqlStore.batchOperations(operations, (error) => {
+                // eslint-disable-next-line no-unused-expressions
                 error ? reject(error) : resolve();
             });
         });
@@ -98670,7 +98992,7 @@ function initializeOneStore(sqliteStore, luvio) {
         buildServiceDescriptor$7(),
         buildServiceDescriptor$1$1(),
         buildServiceDescriptor$2(),
-        // TODO[@W-18753648]: See note above.
+        // TODO [W-18753648]: See note above.
         // buildStreamingCommandServiceDescriptor(),
         // buildNdJsonServiceDescriptor(),
         // buildSseCommandServiceDescriptor(),
@@ -98929,378 +99251,12 @@ register$1({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$2,
 });
-// version: 1.432.0-a57c62b660
+// 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.
@@ -99349,35 +99305,35 @@ function extractValue(valueNode, variableDefinitions, expectedType) {
 function extractVariableValue(variableName, variableDefinitions) {
   const variable = variableDefinitions[variableName];
   if (!variable) {
-    return err$4(
+    return err$3(
       new Error(`Variable '${variableName}' was used in the query but was not defined`)
     );
   }
   if (variable.value !== void 0) {
-    return ok$4(variable.value);
+    return ok$3(variable.value);
   }
   if (variable.definition.defaultValue) {
     return extractValue(variable.definition.defaultValue, variableDefinitions);
   }
-  return ok$4(void 0);
+  return ok$3(void 0);
 }
 function validateExpectedType(value, expectedType) {
   if (!expectedType) {
-    return ok$4(value);
+    return ok$3(value);
   }
   if (value === null) {
     if (expectedType.nullable) {
-      return ok$4(value);
+      return ok$3(value);
     } else {
-      return err$4(new Error(`Expected ${expectedType.type}, but got null`));
+      return err$3(new Error(`Expected ${expectedType.type}, but got null`));
     }
   }
   const actualType = typeof value;
   if (actualType === expectedType.type) {
-    return ok$4(value);
+    return ok$3(value);
   }
   const expectedTypeString = expectedType.nullable ? `${expectedType.type} | null` : expectedType.type;
-  return err$4(
+  return err$3(
     new Error(`Expected ${expectedTypeString}, but got ${actualType}: ${JSON.stringify(value)}`)
   );
 }
@@ -99420,10 +99376,10 @@ function findExecutableOperation(input) {
     (def) => def.kind === Kind$1.OPERATION_DEFINITION
   );
   if (operations.length === 0) {
-    return err$4(new Error("No operations found in query"));
+    return err$3(new Error("No operations found in query"));
   }
   if (operations.length === 1 && !input.operationName) {
-    return ok$4(operations[0]);
+    return ok$3(operations[0]);
   }
   if (input.operationName) {
     const specifiedOperation = operations.find((op) => {
@@ -99431,16 +99387,16 @@ function findExecutableOperation(input) {
       return ((_a = op.name) == null ? void 0 : _a.value) === input.operationName;
     });
     if (specifiedOperation) {
-      return ok$4(specifiedOperation);
+      return ok$3(specifiedOperation);
     }
-    return err$4(new Error(`Operation "${input.operationName}" not found in query`));
+    return err$3(new Error(`Operation "${input.operationName}" not found in query`));
   }
-  return err$4(new Error("Multiple operations found in query, and no operation name provided"));
+  return err$3(new Error("Multiple operations found in query, and no operation name provided"));
 }
 function buildGraphQLInputExtension(input) {
   const operationResult = findExecutableOperation(input);
   if (operationResult.isErr()) {
-    return err$4(operationResult.error);
+    return err$3(operationResult.error);
   }
   const operation = operationResult.value;
   const selections = operation.selectionSet.selections;
@@ -99457,7 +99413,7 @@ function buildGraphQLInputExtension(input) {
     prev[fragment.name.value] = fragment;
     return prev;
   }, {});
-  return ok$4({
+  return ok$3({
     selections,
     request: { definitions: { variables, fragments } },
     parentFieldSelection: void 0
@@ -99615,13 +99571,13 @@ function collectFieldNames(selections, fragments) {
 }
 function buildFieldKey(canonicalFieldName, fieldArguments, variables) {
   if (fieldArguments === void 0 || fieldArguments.length === 0) {
-    return ok$4(canonicalFieldName);
+    return ok$3(canonicalFieldName);
   }
   const formattedArguments = {};
   for (const arg of fieldArguments) {
     const result = extractValue(arg.value, variables);
     if (result.isErr()) {
-      return err$4(
+      return err$3(
         new Error(
           `Failed to extract argument '${arg.name.value}' for field '${canonicalFieldName}': ${result.error.message}`
         )
@@ -99629,7 +99585,7 @@ function buildFieldKey(canonicalFieldName, fieldArguments, variables) {
     }
     formattedArguments[arg.name.value] = result.value;
   }
-  return ok$4(`${canonicalFieldName}::${stableJSONStringify$3({ args: formattedArguments })}`);
+  return ok$3(`${canonicalFieldName}::${stableJSONStringify$3({ args: formattedArguments })}`);
 }
 ({
   kind: Kind$1.FIELD,
@@ -99654,17 +99610,17 @@ function extractIfArgument(directive, variables, directiveName) {
   var _a;
   const ifArg = (_a = directive.arguments) == null ? void 0 : _a.find((arg) => arg.name.value === "if");
   if (!ifArg) {
-    return err$4(new Error(`@${directiveName} directive requires an 'if' argument`));
+    return err$3(new Error(`@${directiveName} directive requires an 'if' argument`));
   }
   const result = extractValue(ifArg.value, variables, { type: "boolean", nullable: false });
   if (result.isErr()) {
-    return err$4(result.error);
+    return err$3(result.error);
   }
-  return ok$4(result.value);
+  return ok$3(result.value);
 }
 function shouldSkip(selection, variables) {
   if (!selection.directives || selection.directives.length === 0) {
-    return ok$4(false);
+    return ok$3(false);
   }
   for (const directive of selection.directives) {
     if (directive.name.value === "skip") {
@@ -99673,7 +99629,7 @@ function shouldSkip(selection, variables) {
         return ifResult;
       }
       if (ifResult.value === true) {
-        return ok$4(true);
+        return ok$3(true);
       }
     }
     if (directive.name.value === "include") {
@@ -99682,11 +99638,11 @@ function shouldSkip(selection, variables) {
         return ifResult;
       }
       if (ifResult.value === false) {
-        return ok$4(true);
+        return ok$3(true);
       }
     }
   }
-  return ok$4(false);
+  return ok$3(false);
 }
 class BaseScalarFieldDef {
   constructor(nullable) {
@@ -99694,11 +99650,11 @@ class BaseScalarFieldDef {
   }
   write(_cache, input) {
     if (input.data === void 0) {
-      return ok$4({ type: "missing" });
+      return ok$3({ type: "missing" });
     }
     if (input.data === null) {
       if (!this.nullable) {
-        return err$4([
+        return err$3([
           {
             type: "unknown",
             error: new Error(
@@ -99708,14 +99664,14 @@ class BaseScalarFieldDef {
         ]);
       }
     }
-    return ok$4({ type: "data", data: input.data });
+    return ok$3({ type: "data", data: input.data });
   }
   read(_cache, input) {
     const normalizedData = input.normalizedData;
     if (normalizedData.type === "missing") {
-      return ok$4(void 0);
+      return ok$3(void 0);
     }
-    return ok$4(normalizedData.data);
+    return ok$3(normalizedData.data);
   }
   augmentSelections(input) {
     return input;
@@ -99737,11 +99693,11 @@ class BaseArrayFieldDef {
   }
   write(cache, input) {
     if (input.data === void 0) {
-      return ok$4({ type: "missing" });
+      return ok$3({ type: "missing" });
     }
     if (input.data === null) {
       if (!this.nullable) {
-        return err$4([
+        return err$3([
           {
             type: "unknown",
             error: new Error(
@@ -99750,10 +99706,10 @@ class BaseArrayFieldDef {
           }
         ]);
       }
-      return ok$4({ type: "data", data: input.data });
+      return ok$3({ type: "data", data: input.data });
     }
     if (!Array.isArray(input.data)) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -99781,18 +99737,18 @@ class BaseArrayFieldDef {
       }
     });
     if (arrayNormalizationErrors.length > 0) {
-      return err$4(arrayNormalizationErrors);
+      return err$3(arrayNormalizationErrors);
     }
-    return ok$4({ type: "data", data: normalizedArray });
+    return ok$3({ type: "data", data: normalizedArray });
   }
   read(cache, input) {
     const normalizedData = input.normalizedData;
     if (normalizedData.type === "missing") {
-      return ok$4(void 0);
+      return ok$3(void 0);
     }
     if (normalizedData.data === null) {
       if (!this.nullable) {
-        return err$4([
+        return err$3([
           {
             type: "unknown",
             error: new Error(
@@ -99801,10 +99757,10 @@ class BaseArrayFieldDef {
           }
         ]);
       }
-      return ok$4({ type: "data", data: null });
+      return ok$3({ type: "data", data: null });
     }
     if (!Array.isArray(normalizedData.data)) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -99829,9 +99785,9 @@ class BaseArrayFieldDef {
       }
     });
     if (arrayDenormalizationErrors.length > 0) {
-      return err$4(arrayDenormalizationErrors);
+      return err$3(arrayDenormalizationErrors);
     }
-    return ok$4(denormalizedArray);
+    return ok$3(denormalizedArray);
   }
 }
 class BaseObjectFieldDef {
@@ -99848,7 +99804,7 @@ class BaseObjectFieldDef {
   write(cache, input) {
     var _a;
     if (!input.selection.selectionSet) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -99858,11 +99814,11 @@ class BaseObjectFieldDef {
       ]);
     }
     if (input.data === void 0) {
-      return ok$4({ type: "missing" });
+      return ok$3({ type: "missing" });
     }
     if (input.data === null) {
       if (!this.nullable) {
-        return err$4([
+        return err$3([
           {
             type: "unknown",
             error: new Error(
@@ -99871,7 +99827,7 @@ class BaseObjectFieldDef {
           }
         ]);
       }
-      return ok$4({ type: "data", data: null });
+      return ok$3({ type: "data", data: null });
     }
     const writeResult = this.repository.write(cache, {
       ...input,
@@ -99884,12 +99840,12 @@ class BaseObjectFieldDef {
     if (writeResult.isErr()) {
       return writeResult;
     }
-    return ok$4({ type: "data", data: writeResult.value });
+    return ok$3({ type: "data", data: writeResult.value });
   }
   read(cache, input) {
     var _a;
     if (!input.selection.selectionSet) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -99900,11 +99856,11 @@ class BaseObjectFieldDef {
     }
     const normalizedData = input.normalizedData;
     if (normalizedData.type === "missing") {
-      return ok$4(void 0);
+      return ok$3(void 0);
     }
     if (normalizedData.data === null) {
       if (!this.nullable) {
-        return err$4([
+        return err$3([
           {
             type: "unknown",
             error: new Error(
@@ -99913,7 +99869,7 @@ class BaseObjectFieldDef {
           }
         ]);
       }
-      return ok$4(null);
+      return ok$3(null);
     }
     return this.repository.read(cache, {
       ...input,
@@ -100196,7 +100152,7 @@ class BaseGraphQLTypeRepository {
     var _a;
     const fieldDef = this.getFieldDef(input, selection);
     if (!fieldDef) {
-      return err$4(
+      return err$3(
         new Error(
           `Unknown field "${selection.name.value}" on type "${this.typeName}". Expected one of fields ${Object.keys(this.fields)}.`
         )
@@ -100207,10 +100163,10 @@ class BaseGraphQLTypeRepository {
       input.request.definitions.variables
     );
     if (cacheFieldKeyResult.isErr()) {
-      return err$4(cacheFieldKeyResult.error);
+      return err$3(cacheFieldKeyResult.error);
     }
     const cacheFieldKey = cacheFieldKeyResult.value;
-    return ok$4((_a = input.existingNormalizedData || input.normalizedData) == null ? void 0 : _a[cacheFieldKey]);
+    return ok$3((_a = input.existingNormalizedData || input.normalizedData) == null ? void 0 : _a[cacheFieldKey]);
   }
   denormalizeFieldSelection(cache, input, selection, errorCollector) {
     var _a;
@@ -100316,22 +100272,22 @@ class BaseGraphQLTypeRepository {
       return shouldSkipResult;
     }
     if (shouldSkipResult.value) {
-      return ok$4(false);
+      return ok$3(false);
     }
     return this.satisfiesFragmentTypeCondition(input, fragment);
   }
   satisfiesFragmentTypeCondition(_input, fragment) {
     if (!fragment.typeCondition) {
-      return ok$4(true);
+      return ok$3(true);
     }
     const conditionalTypeName = fragment.typeCondition.name.value;
     if (conditionalTypeName === this.typeName) {
-      return ok$4(true);
+      return ok$3(true);
     }
     if (this.implementedInterfaces.includes(conditionalTypeName)) {
-      return ok$4(true);
+      return ok$3(true);
     }
-    return ok$4(false);
+    return ok$3(false);
   }
   getCacheKeyFieldArguments(selection) {
     return selection.arguments;
@@ -100390,7 +100346,7 @@ class IdentifiableGraphQLTypeRepository extends IdentifiableTypeRepository {
     const key = this.buildKey(this.buildKeyParams(input));
     const normalized = this.normalizeData(cache, input);
     if (normalized.isErr()) {
-      return err$4(normalized.error);
+      return err$3(normalized.error);
     }
     const existing = cache.get(key);
     if (!deepEquals$2(existing == null ? void 0 : existing.value, normalized.value)) {
@@ -100399,7 +100355,7 @@ class IdentifiableGraphQLTypeRepository extends IdentifiableTypeRepository {
         metadata: this.cacheMetadata
       });
     }
-    return ok$4({
+    return ok$3({
       type: "link",
       linkedKey: key
     });
@@ -100414,7 +100370,7 @@ class IdentifiableGraphQLTypeRepository extends IdentifiableTypeRepository {
     if (normalizeDataResult.isErr()) {
       return normalizeDataResult;
     }
-    return ok$4(
+    return ok$3(
       deepMerge$2(
         {},
         (existingNormalizedData == null ? void 0 : existingNormalizedData.value) || {},
@@ -100484,7 +100440,7 @@ class GraphQLDocumentRootTypeRepository extends IdentifiableGraphQLTypeRepositor
     if (result.isErr()) {
       return result;
     }
-    return ok$4({
+    return ok$3({
       data: result.value
     });
   }
@@ -100492,7 +100448,7 @@ class GraphQLDocumentRootTypeRepository extends IdentifiableGraphQLTypeRepositor
     var _a;
     const operationResult = findExecutableOperation(input);
     if (operationResult.isErr()) {
-      return err$4(operationResult.error);
+      return err$3(operationResult.error);
     }
     const operation = operationResult.value;
     const fragmentDefinitions = input.query.definitions.filter(
@@ -100515,7 +100471,7 @@ class GraphQLDocumentRootTypeRepository extends IdentifiableGraphQLTypeRepositor
       ...operation,
       selectionSet: { kind: Kind$1.SELECTION_SET, selections: augmentedOperationSelections }
     };
-    return ok$4({
+    return ok$3({
       ...input.query,
       definitions: [
         ...input.query.definitions.filter((def) => def.kind !== Kind$1.FRAGMENT_DEFINITION).map((def) => {
@@ -100550,7 +100506,7 @@ class BaseInterfaceRepository {
   }
   write(cache, input) {
     if (typeof input.data !== "object") {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(`Got a non-object value for ${this.typeName} field"`)
@@ -100560,7 +100516,7 @@ class BaseInterfaceRepository {
     const discriminator = this.getTypeDiscriminator(input.data, input.selections);
     const concreteTypeRepository = this.possibleTypes[discriminator];
     if (!concreteTypeRepository) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -100571,7 +100527,7 @@ class BaseInterfaceRepository {
     }
     const selectionErr = this.verifyInterfaceFields(input.selections);
     if (selectionErr) {
-      return err$4(selectionErr);
+      return err$3(selectionErr);
     }
     const normalizeInput = {
       ...input,
@@ -100583,14 +100539,14 @@ class BaseInterfaceRepository {
     };
     const result = concreteTypeRepository.write(cache, normalizeInput);
     if (result.isOk()) {
-      return ok$4({ discriminator, data: result.value });
+      return ok$3({ discriminator, data: result.value });
     }
     return result;
   }
   read(cache, input) {
     const unionRep = input.normalizedData;
     if (typeof unionRep.data !== "object" || unionRep.data === null) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(`Got a non-object value for ${this.typeName} field.`)
@@ -100600,7 +100556,7 @@ class BaseInterfaceRepository {
     const discriminator = unionRep.discriminator;
     const concreteRepository = this.possibleTypes[discriminator];
     if (!concreteRepository) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -100611,7 +100567,7 @@ class BaseInterfaceRepository {
     }
     const selectionErr = this.verifyInterfaceFields(input.selections);
     if (selectionErr) {
-      return err$4(selectionErr);
+      return err$3(selectionErr);
     }
     const denormalizeInput = {
       ...input,
@@ -100716,7 +100672,7 @@ class BaseUnionRepository {
   }
   write(cache, input) {
     if (typeof input.data !== "object") {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(`Got a non-object value for ${this.typeName} field"`)
@@ -100726,7 +100682,7 @@ class BaseUnionRepository {
     const discriminator = this.getTypeDiscriminator(input.data, input.selections);
     const concreteTypeRepository = this.possibleTypes[discriminator];
     if (!concreteTypeRepository) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -100737,7 +100693,7 @@ class BaseUnionRepository {
     }
     const selectionErr = this.verifyUnionFields(input.selections);
     if (selectionErr) {
-      return err$4(selectionErr);
+      return err$3(selectionErr);
     }
     const normalizeInput = {
       ...input,
@@ -100749,14 +100705,14 @@ class BaseUnionRepository {
     };
     const result = concreteTypeRepository.write(cache, normalizeInput);
     if (result.isOk()) {
-      return ok$4({ discriminator, data: result.value });
+      return ok$3({ discriminator, data: result.value });
     }
     return result;
   }
   read(cache, input) {
     const unionRep = input.normalizedData;
     if (typeof unionRep.data !== "object" || unionRep.data === null) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(`Got a non-object value for ${this.typeName} field.`)
@@ -100766,7 +100722,7 @@ class BaseUnionRepository {
     const discriminator = unionRep.discriminator;
     const concreteRepository = this.possibleTypes[discriminator];
     if (!concreteRepository) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -100777,7 +100733,7 @@ class BaseUnionRepository {
     }
     const selectionErr = this.verifyUnionFields(input.selections);
     if (selectionErr) {
-      return err$4(selectionErr);
+      return err$3(selectionErr);
     }
     const denormalizeInput = {
       ...input,
@@ -105296,7 +105252,7 @@ function dataSatisfiesFragmentTypeCondition(input, fragment) {
  * @param typeName - The repository type name for error messages
  * @returns Result<boolean, Error> - true if the fragment type condition is satisfied
  */
-function genericSatisfiesFragmentTypeCondition(superSatisfiesFragmentTypeCondition, input, fragment, typeName) {
+function genericSatisfiesFragmentTypeCondition(superSatisfiesFragmentTypeCondition, input, fragment, _typeName) {
     // First try the base class implementation
     const result = superSatisfiesFragmentTypeCondition(input, fragment);
     if (result.isErr() || result.value) {
@@ -105764,7 +105720,7 @@ class SetupRecordAggregateRepository extends Setup__SetupRecordAggregateReposito
 }
 
 class PolymorphicParentRelationshipRepository extends PolymorphicParentRelationshipRepository$1 {
-    getTypeDiscriminator(data, _selections) {
+    getTypeDiscriminator(_data, _selections) {
         // Hardcoded to record representation since that's the only type of parent
         // relationship possible
         return 'RecordRepresentation';
@@ -105804,7 +105760,7 @@ class SetupEdgeRepository extends Setup__SetupEdgeRepository {
 }
 
 class PolymorphicAggregateParentRelationshipRepository extends PolymorphicAggregateParentRelationshipRepository$1 {
-    getTypeDiscriminator(data, _selections) {
+    getTypeDiscriminator(_data, _selections) {
         // Hardcoded to record aggregate since that's the only type of parent
         // relationship possible
         return 'RecordAggregate';
@@ -105861,6 +105817,7 @@ class RecordDeletePayloadRepository extends RecordDeletePayloadRepository$1 {
         let idFieldSelection = input.selections.find((selection) => selection.kind === 'Field' && selection.name.value === 'Id');
         // If Id exists in data but wasn't asked for, synthesize the selection like RecordRepresentation does
         if (input.data.Id !== undefined && !idFieldSelection) {
+            // eslint-disable-next-line no-param-reassign
             input = {
                 ...input,
                 selections: [
@@ -105908,7 +105865,7 @@ class SetupConnectionRepository extends Setup__SetupConnectionRepository {
 }
 
 class SetupPolymorphicAggregateParentRelationshipRepository extends Setup__SetupPolymorphicAggregateParentRelationshipRepository {
-    getTypeDiscriminator(data, _selections) {
+    getTypeDiscriminator(_data, _selections) {
         // Hardcoded to Setup__SetupRecordAggregate since that's the only type of parent
         // relationship possible
         return 'Setup__SetupRecordAggregate';
@@ -105916,7 +105873,7 @@ class SetupPolymorphicAggregateParentRelationshipRepository extends Setup__Setup
 }
 
 class SetupPolymorphicParentRelationshipRepository extends Setup__SetupPolymorphicParentRelationshipRepository {
-    getTypeDiscriminator(data, _selections) {
+    getTypeDiscriminator(_data, _selections) {
         // Hardcoded to Setup__EntityRepresentation since that's the only type of parent
         // relationship possible
         return 'Setup__EntityRepresentation';
@@ -106057,6 +106014,7 @@ function deepMerge$1(data, extensions) {
     const dataType = typeof data;
     const extensionsType = typeof extensions;
     if (dataType === 'function' || extensionsType === 'function') {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
         throw new Error('Cannot merge functions');
     }
     if (dataType === 'undefined' || data === undefined) {
@@ -106397,7 +106355,9 @@ function buildCommandClass(baseClass) {
                     });
                     this.unsubscribers.push(unsubscribeFromLuvioSnapshot);
                 }
-                catch (error) { }
+                catch (error) {
+                    // intentionally do nothing
+                }
             }
         }
         usedRecordsChanged() {
@@ -106503,6 +106463,7 @@ function defaultCheckConfig(config, requiredKeys, optionalKeys) {
     const invalidKeys = configKeys.filter((key) => !allowedKeysSet.includes(key));
     if (invalidKeys.length > 0) {
         // invalid keys, so set error state
+        // eslint-disable-next-line no-throw-literal
         throw {
             error: `Invalid config keys: ${invalidKeys.join(', ')}`,
             errorType: 'adapterError',
@@ -106867,7 +106828,7 @@ getServices(serviceRequirements).then((services) => {
         _(config, CONFIG_SCHEMA);
         const baseCommand = new graphql_imperative_ctor(config, documentRootType, services);
         return applyDecorators(baseCommand, [services.fetchNetworkCommandBaseClass.availableDecorators.abortable], options);
-    }, false);
+    }, true);
     graphql_imperative_legacy = services.graphQLLegacyImperativeBindings.bind(({ config, assertIsValid }) => {
         const _ = assertIsValid;
         _(config, CONFIG_SCHEMA);
@@ -106877,6 +106838,7 @@ getServices(serviceRequirements).then((services) => {
         services.graphQLLegacyImperativeBindings.bind(({ config, assertIsValid }) => {
             const validatedConfig = validateNonQueryGraphQLConfig(config);
             if (validatedConfig.isErr()) {
+                // eslint-disable-next-line @salesforce/lds/no-error-in-production
                 throw new Error(`Invalid configuration passed to GraphQL: ${validatedConfig.error}`);
             }
             const _ = assertIsValid;
@@ -106888,11 +106850,12 @@ getServices(serviceRequirements).then((services) => {
      */
     const graphql_state_manager_ctor = services.instrumentCommand(buildCommandClass(services.auraGraphQLNormalizedCacheControlCommand), 'graphql_state_manager');
     const factory = (config) => {
-        assertIsValid(config, CONFIG_SCHEMA);
+        assertIsValid$1(config, CONFIG_SCHEMA);
         const validatedConfig = resolveAndValidateGraphQLConfig(config, {
             acceptedOperations: ['query'],
         });
         if (validatedConfig === undefined || validatedConfig.isErr()) {
+            // eslint-disable-next-line @salesforce/lds/no-error-in-production
             throw new Error('Internal error in GraphQL adapter occurred: Unable to resolve query');
         }
         return new graphql_state_manager_ctor(validatedConfig.value, documentRootType, services);
@@ -106920,7 +106883,7 @@ function registerCallback(cb) {
         cb(graphql_v1_import, graphql_imperative$1, graphql_imperative_legacy_v1_import, graphql_state_manager, useOneStoreGraphQL);
     }
 }
-// version: 1.432.0-b99ba9d219
+// version: 1.434.0-6aa2dd15e3
 
 function createFragmentMap(documentNode) {
     const fragments = {};
@@ -134949,28 +134912,23 @@ let configurableCreateContentVersion$1 = new Configurable$1();
  * Depth to which tracked fields will be added to a request that results from a cache miss.
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMiss$1 = 5;
+let trackedFieldDepthOnCacheMiss$1 = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a merge conflict
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMergeConflict$1 = 5;
+let trackedFieldDepthOnCacheMergeConflict$1 = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a notify change invocation by the consumer
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnNotifyChange$1 = 5;
-/**
- * Determines if we will only fetch the 'Id' field for the leaf relationship record
- * @defaultValue 'false', replicates the current behavior and fetches all fields in the store for the leaf relationship record
- */
-let trackedFieldLeafNodeIdAndNameOnly$1 = false;
+let trackedFieldDepthOnNotifyChange$1 = 1;
 /**
  * One store enabled Get Object Info adapter
  */
@@ -135067,12 +135025,6 @@ const configurationForRestAdapters$1 = {
     getTrackedFieldDepthOnNotifyChange: function () {
         return trackedFieldDepthOnNotifyChange$1;
     },
-    setTrackedFieldLeafNodeIdAndNameOnly: function (trackedFieldLeafNodeIdAndNameOnlyParam) {
-        trackedFieldLeafNodeIdAndNameOnly$1 = trackedFieldLeafNodeIdAndNameOnlyParam;
-    },
-    getTrackedFieldLeafNodeIdAndNameOnly: function () {
-        return trackedFieldLeafNodeIdAndNameOnly$1;
-    },
     setRecordRepresentationIngestionOverride: function (ingest) {
         recordRepresentationIngestionOverride$1 = ingest;
     },
@@ -135629,6 +135581,7 @@ withDefaultLuvio((luvio) => {
                 if (typeof data?.refresh === 'function') {
                     return data.refresh();
                 }
+                // eslint-disable-next-line @salesforce/lds/no-error-in-production
                 throw new Error('Component attempted to refresh a GraphQL result that is not refreshable');
             };
         }
@@ -136137,7 +136090,7 @@ register$1({
     configuration: { ...configurationForGraphQLAdapters$1 },
     instrument: instrument$1,
 });
-// version: 1.432.0-b99ba9d219
+// version: 1.434.0-6aa2dd15e3
 
 // On core the unstable adapters are re-exported with different names,
 // we want to match them here.
@@ -136289,7 +136242,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.432.0-b99ba9d219
+// version: 1.434.0-6aa2dd15e3
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -137088,7 +137041,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.432.0-a57c62b660
+// version: 1.434.0-d8deb0d4ea
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -137124,28 +137077,23 @@ let configurableCreateContentVersion = new Configurable();
  * Depth to which tracked fields will be added to a request that results from a cache miss.
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMiss = 5;
+let trackedFieldDepthOnCacheMiss = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a merge conflict
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
+ * @defaultValue '1'
  */
-let trackedFieldDepthOnCacheMergeConflict = 5;
+let trackedFieldDepthOnCacheMergeConflict = 1;
 /**
  * Depth to which tracked fields will be added to a request that results from a notify change invocation by the consumer
  * A value of 0 inhibits the addition of tracked fields, 1 will add tracked fields that can
  * be reached by following 1 relationship from the root record, etc.
- * @defaultValue '5', replicates the current behavior
- */
-let trackedFieldDepthOnNotifyChange = 5;
-/**
- * Determines if we will only fetch the 'Id' field for the leaf relationship record
- * @defaultValue 'false', replicates the current behavior and fetches all fields in the store for the leaf relationship record
+ * @defaultValue '1'
  */
-let trackedFieldLeafNodeIdAndNameOnly = false;
+let trackedFieldDepthOnNotifyChange = 1;
 /**
  * One store enabled Get Object Info adapter
  */
@@ -137242,12 +137190,6 @@ const configurationForRestAdapters = {
     getTrackedFieldDepthOnNotifyChange: function () {
         return trackedFieldDepthOnNotifyChange;
     },
-    setTrackedFieldLeafNodeIdAndNameOnly: function (trackedFieldLeafNodeIdAndNameOnlyParam) {
-        trackedFieldLeafNodeIdAndNameOnly = trackedFieldLeafNodeIdAndNameOnlyParam;
-    },
-    getTrackedFieldLeafNodeIdAndNameOnly: function () {
-        return trackedFieldLeafNodeIdAndNameOnly;
-    },
     setRecordRepresentationIngestionOverride: function (ingest) {
         recordRepresentationIngestionOverride = ingest;
     },
@@ -138142,6 +138084,7 @@ function handleInstrumentation(activity, stat, progress) {
 const LUVIO_ADAPTER_FAMILY = /^force\/ldsAdapters/;
 async function importLuvioAdapterModule(specifier) {
     if (!LUVIO_ADAPTER_FAMILY.test(specifier)) {
+        // eslint-disable-next-line no-throw-literal
         throw `${specifier} is not an allowed luvio adapter module`;
     }
     let module;
@@ -138149,6 +138092,7 @@ async function importLuvioAdapterModule(specifier) {
         module = await import(specifier);
     }
     catch {
+        // eslint-disable-next-line no-throw-literal
         throw `module not found for specifier ${specifier}`;
     }
     return new LuvioAdapterModule(module);
@@ -138262,6 +138206,7 @@ function buildNativeResponse(response) {
 }
 async function importOneStoreAdapterModule(specifier) {
     if (!ONESTORE_ADAPTER_FAMILY.test(specifier)) {
+        // eslint-disable-next-line no-throw-literal
         throw `${specifier} is not an allowed onestore adapter module`;
     }
     let module;
@@ -138269,6 +138214,7 @@ async function importOneStoreAdapterModule(specifier) {
         module = await import(specifier);
     }
     catch {
+        // eslint-disable-next-line no-throw-literal
         throw `module not found for specifier ${specifier}`;
     }
     return new OneStoreAdapterModule(module);
@@ -138384,4 +138330,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, evictExpiredCacheEntries, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, importLuvioAdapterModule, importOneStoreAdapterModule, invokeAdapter, invokeAdapterWithDraftToMerge, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, stopEviction, subscribeToAdapter };
-// version: 1.432.0-a57c62b660
+// version: 1.434.0-d8deb0d4ea