@ember-data/store 5.4.0-alpha.3 → 5.4.0-alpha.31

package/addon/{store-service-0a03d2a4.js → cache-handler-oB00-31L.js}

@@ -1,365 +1,17 @@
-import { macroCondition, getOwnConfig } from '@embroider/macros';
-import { getOwner } from '@ember/application';
-import { assert, deprecate, warn } from '@ember/debug';
+import { deprecate, assert, warn } from '@ember/debug';
 import EmberObject from '@ember/object';
-import { _backburner } from '@ember/runloop';
-import { tracked } from '@glimmer/tracking';
+import { SkipCache, EnableHydration } from '@warp-drive/core-types/request';
+import { macroCondition, getOwnConfig } from '@embroider/macros';
+import { CACHE_OWNER, DEBUG_STALE_CACHE_OWNER, DEBUG_CLIENT_ORIGINATED, DEBUG_IDENTIFIER_BUCKET } from '@warp-drive/core-types/identifier';
 import { dasherize } from '@ember/string';
-import { addToTransaction, subscribe, addTransactionCB } from '@ember-data/tracking/-private';
-import { tagForProperty } from '@ember/-internals/metal';
-import { dependentKeyCompat } from '@ember/object/compat';
-import { dirtyTag } from '@glimmer/validator';
-import Ember from 'ember';
-function _initializerDefineProperty(target, property, descriptor, context) {
-  if (!descriptor) return;
-  Object.defineProperty(target, property, {
-    enumerable: descriptor.enumerable,
-    configurable: descriptor.configurable,
-    writable: descriptor.writable,
-    value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
-  });
-}
-function _classPrivateFieldBase(receiver, privateKey) {
-  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
-    throw new TypeError("attempted to use private field on non-instance");
-  }
-  return receiver;
-}
-var id = 0;
-function _classPrivateFieldKey(name) {
-  return "__private_" + id++ + "_" + name;
-}
-function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
-  var desc = {};
-  Object.keys(descriptor).forEach(function (key) {
-    desc[key] = descriptor[key];
-  });
-  desc.enumerable = !!desc.enumerable;
-  desc.configurable = !!desc.configurable;
-  if ('value' in desc || desc.initializer) {
-    desc.writable = true;
-  }
-  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
-    return decorator(target, property, desc) || desc;
-  }, desc);
-  if (context && desc.initializer !== void 0) {
-    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
-    desc.initializer = undefined;
-  }
-  if (desc.initializer === void 0) {
-    Object.defineProperty(target, property, desc);
-    desc = null;
-  }
-  return desc;
-}
-var _class$2, _descriptor$2, _descriptor2$1, _descriptor3, _descriptor4, _store, _request;
-function urlFromLink(link) {
-  if (typeof link === 'string') return link;
-  return link.href;
-}
-let Document = (_class$2 = (_store = /*#__PURE__*/_classPrivateFieldKey("store"), _request = /*#__PURE__*/_classPrivateFieldKey("request"), class Document {
-  constructor(store, identifier) {
-    Object.defineProperty(this, _request, {
-      value: _request2
-    });
-    _initializerDefineProperty(this, "links", _descriptor$2, this);
-    _initializerDefineProperty(this, "data", _descriptor2$1, this);
-    _initializerDefineProperty(this, "errors", _descriptor3, this);
-    _initializerDefineProperty(this, "meta", _descriptor4, this);
-    Object.defineProperty(this, _store, {
-      writable: true,
-      value: void 0
-    });
-    _classPrivateFieldBase(this, _store)[_store] = store;
-    this.identifier = identifier;
-  }
-  fetch(options = {}) {
-    assert(`No self link`, this.links?.self);
-    options.cacheOptions = options.cacheOptions || {};
-    options.cacheOptions.key = this.identifier?.lid;
-    return _classPrivateFieldBase(this, _request)[_request]('self', options);
-  }
-  next(options) {
-    return _classPrivateFieldBase(this, _request)[_request]('next', options);
-  }
-  prev(options) {
-    return _classPrivateFieldBase(this, _request)[_request]('prev', options);
-  }
-  first(options) {
-    return _classPrivateFieldBase(this, _request)[_request]('first', options);
-  }
-  last(options) {
-    return _classPrivateFieldBase(this, _request)[_request]('last', options);
-  }
-  toJSON() {
-    const data = {};
-    data.identifier = this.identifier;
-    if (this.data !== undefined) {
-      data.data = this.data;
-    }
-    if (this.links !== undefined) {
-      data.links = this.links;
-    }
-    if (this.errors !== undefined) {
-      data.errors = this.errors;
-    }
-    if (this.meta !== undefined) {
-      data.meta = this.meta;
-    }
-    return data;
-  }
-}), (_descriptor$2 = _applyDecoratedDescriptor(_class$2.prototype, "links", [tracked], {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  initializer: null
-}), _descriptor2$1 = _applyDecoratedDescriptor(_class$2.prototype, "data", [tracked], {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  initializer: null
-}), _descriptor3 = _applyDecoratedDescriptor(_class$2.prototype, "errors", [tracked], {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  initializer: null
-}), _descriptor4 = _applyDecoratedDescriptor(_class$2.prototype, "meta", [tracked], {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  initializer: null
-})), _class$2);
-async function _request2(link, options = {}) {
-  const href = this.links?.[link];
-  if (!href) {
-    return null;
-  }
-  const response = await _classPrivateFieldBase(this, _store)[_store].request(Object.assign(options, {
-    url: urlFromLink(href)
-  }));
-  return response.content;
-}
-function isErrorDocument(document) {
-  return 'errors' in document;
-}
-function maybeUpdateUiObjects(store, request, options, document, isFromCache) {
-  const {
-    identifier
-  } = options;
-  if (isErrorDocument(document)) {
-    if (!identifier && !options.shouldHydrate) {
-      return document;
-    }
-    let doc;
-    if (identifier) {
-      doc = store._documentCache.get(identifier);
-    }
-    if (!doc) {
-      doc = new Document(store, identifier);
-      copyDocumentProperties(doc, document);
-      if (identifier) {
-        store._documentCache.set(identifier, doc);
-      }
-    } else if (!isFromCache) {
-      doc.data = undefined;
-      copyDocumentProperties(doc, document);
-    }
-    return options.shouldHydrate ? doc : document;
-  }
-  if (Array.isArray(document.data)) {
-    const {
-      recordArrayManager
-    } = store;
-    if (!identifier) {
-      if (!options.shouldHydrate) {
-        return document;
-      }
-      const data = recordArrayManager.createArray({
-        type: request.url,
-        identifiers: document.data,
-        doc: document,
-        query: request
-      });
-      const doc = new Document(store, null);
-      doc.data = data;
-      doc.meta = document.meta;
-      doc.links = document.links;
-      return doc;
-    }
-    let managed = recordArrayManager._keyedArrays.get(identifier.lid);
-    if (!managed) {
-      managed = recordArrayManager.createArray({
-        type: identifier.lid,
-        identifiers: document.data,
-        doc: document
-      });
-      recordArrayManager._keyedArrays.set(identifier.lid, managed);
-      const doc = new Document(store, identifier);
-      doc.data = managed;
-      doc.meta = document.meta;
-      doc.links = document.links;
-      store._documentCache.set(identifier, doc);
-      return options.shouldHydrate ? doc : document;
-    } else {
-      const doc = store._documentCache.get(identifier);
-      if (!isFromCache) {
-        recordArrayManager.populateManagedArray(managed, document.data, document);
-        doc.data = managed;
-        doc.meta = document.meta;
-        doc.links = document.links;
-      }
-      return options.shouldHydrate ? doc : document;
-    }
-  } else {
-    if (!identifier && !options.shouldHydrate) {
-      return document;
-    }
-    const data = document.data ? store.peekRecord(document.data) : null;
-    let doc;
-    if (identifier) {
-      doc = store._documentCache.get(identifier);
-    }
-    if (!doc) {
-      doc = new Document(store, identifier);
-      doc.data = data;
-      copyDocumentProperties(doc, document);
-      if (identifier) {
-        store._documentCache.set(identifier, doc);
-      }
-    } else if (!isFromCache) {
-      doc.data = data;
-      copyDocumentProperties(doc, document);
-    }
-    return options.shouldHydrate ? doc : document;
-  }
-}
-function calcShouldFetch(store, request, hasCachedValue, identifier) {
-  const {
-    cacheOptions
-  } = request;
-  return cacheOptions?.reload || !hasCachedValue || (store.lifetimes && identifier ? store.lifetimes.isHardExpired(identifier) : false);
-}
-function calcShouldBackgroundFetch(store, request, willFetch, identifier) {
-  const {
-    cacheOptions
-  } = request;
-  return !willFetch && (cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier) : false));
-}
-function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBackgroundFetch) {
-  const {
-    store
-  } = context.request;
-  const shouldHydrate = context.request[Symbol.for('ember-data:enable-hydration')] || false;
-  return next(context.request).then(document => {
-    store.requestManager._pending.delete(context.id);
-    store._enableAsyncFlush = true;
-    let response;
-    store._join(() => {
-      response = store.cache.put(document);
-      response = maybeUpdateUiObjects(store, context.request, {
-        shouldHydrate,
-        shouldFetch,
-        shouldBackgroundFetch,
-        identifier
-      }, response, false);
-    });
-    store._enableAsyncFlush = null;
-    if (shouldFetch) {
-      return response;
-    } else if (shouldBackgroundFetch) {
-      store.notifications._flush();
-    }
-  }, error => {
-    store.requestManager._pending.delete(context.id);
-    if (context.request.signal?.aborted) {
-      throw error;
-    }
-    store.requestManager._pending.delete(context.id);
-    store._enableAsyncFlush = true;
-    let response;
-    store._join(() => {
-      response = store.cache.put(error);
-      response = maybeUpdateUiObjects(store, context.request, {
-        shouldHydrate,
-        shouldFetch,
-        shouldBackgroundFetch,
-        identifier
-      }, response, false);
-    });
-    store._enableAsyncFlush = null;
-    if (!shouldBackgroundFetch) {
-      const newError = cloneError(error);
-      newError.content = response;
-      throw newError;
-    } else {
-      store.notifications._flush();
-    }
-  });
-}
-function cloneError(error) {
-  const cloned = new Error(error.message);
-  cloned.stack = error.stack;
-  cloned.error = error.error;
-  return cloned;
-}
-const SkipCache = Symbol.for('ember-data:skip-cache');
-const EnableHydration = Symbol.for('ember-data:enable-hydration');
-const CacheHandler = {
-  request(context, next) {
-    // if we have no cache or no cache-key skip cache handling
-    if (!context.request.store || context.request.cacheOptions?.[SkipCache]) {
-      return next(context.request);
-    }
-    const {
-      store
-    } = context.request;
-    const identifier = store.identifierCache.getOrCreateDocumentIdentifier(context.request);
-    const peeked = identifier ? store.cache.peekRequest(identifier) : null;
-
-    // determine if we should skip cache
-    if (calcShouldFetch(store, context.request, !!peeked, identifier)) {
-      return fetchContentAndHydrate(next, context, identifier, true, false);
-    }
+import { defineSignal, addToTransaction, createSignal, subscribe, createArrayTags, addTransactionCB } from '@ember-data/tracking/-private';
+import { _backburner } from '@ember/runloop';
+import { compat } from '@ember-data/tracking';
 
-    // if we have not skipped cache, determine if we should update behind the scenes
-    if (calcShouldBackgroundFetch(store, context.request, false, identifier)) {
-      let promise = fetchContentAndHydrate(next, context, identifier, false, true);
-      store.requestManager._pending.set(context.id, promise);
-    }
-    const shouldHydrate = context.request[EnableHydration] || false;
-    if ('error' in peeked) {
-      const content = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
-        shouldHydrate,
-        identifier
-      }, peeked.content, true) : peeked.content;
-      const newError = cloneError(peeked);
-      newError.content = content;
-      throw newError;
-    }
-    return Promise.resolve(shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
-      shouldHydrate,
-      identifier
-    }, peeked.content, true) : peeked.content);
-  }
-};
-function copyDocumentProperties(target, source) {
-  if ('links' in source) {
-    target.links = source.links;
-  }
-  if ('meta' in source) {
-    target.meta = source.meta;
-  }
-  if ('errors' in source) {
-    target.errors = source.errors;
-  }
-}
+/**
+  @module @ember-data/store
+*/
 
-// Used by the store to normalize IDs entering the store.  Despite the fact
-// that developers may provide IDs as numbers (e.g., `store.findRecord('person', 1)`),
-// it is important that internally we use strings, since IDs may be serialized
-// and lose type information.  For example, Ember's router may put a record's
-// ID into the URL, and if we later try to deserialize that URL and find the
-// corresponding record, we will not know if it is a string or a number.
 function coerceId(id) {
   if (macroCondition(getOwnConfig().deprecations.DEPRECATE_NON_STRICT_ID)) {
     let normalized;
@@ -392,10 +44,6 @@ function ensureStringId(id) {
   assert(`Expected id to be a string or number, received ${String(id)}`, normalized !== null);
   return normalized;
 }
-
-// provided for additional debuggability
-const DEBUG_CLIENT_ORIGINATED = Symbol('record-originated-on-client');
-const DEBUG_IDENTIFIER_BUCKET = Symbol('identifier-bucket');
 function normalizeModelName(type) {
   if (macroCondition(getOwnConfig().deprecations.DEPRECATE_NON_STRICT_TYPES)) {
     const result = dasherize(type);
@@ -424,7 +72,7 @@ function installPolyfill() {
     // we might be able to optimize this by requesting more bytes than we need at a time
     const rng = function () {
       // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto
-      let rnds8 = new Uint8Array(16);
+      const rnds8 = new Uint8Array(16);
       if (!CRYPTO.getRandomValues && !isFastBoot) {
         throw new Error(`Unable to generate bytes for UUID`);
       }
@@ -440,12 +88,12 @@ function installPolyfill() {
       byteToHex[i] = (i + 0x100).toString(16).substr(1);
     }
     const bytesToUuid = function (buf) {
-      let bth = byteToHex;
+      const bth = byteToHex;
       // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4
       return [bth[buf[0]], bth[buf[1]], bth[buf[2]], bth[buf[3]], '-', bth[buf[4]], bth[buf[5]], '-', bth[buf[6]], bth[buf[7]], '-', bth[buf[8]], bth[buf[9]], '-', bth[buf[10]], bth[buf[11]], bth[buf[12]], bth[buf[13]], bth[buf[14]], bth[buf[15]]].join('');
     };
     CRYPTO.randomUUID = function uuidv4() {
-      let rnds = rng();
+      const rnds = rng();
 
       // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
       rnds[6] = rnds[6] & 0x0f | 0x40;
@@ -476,7 +124,7 @@ function hasType(resource) {
 const IDENTIFIERS = new Set();
 const DOCUMENTS = new Set();
 function isStableIdentifier(identifier) {
-  return IDENTIFIERS.has(identifier);
+  return identifier[CACHE_OWNER] !== undefined || IDENTIFIERS.has(identifier);
 }
 function isDocumentIdentifier(identifier) {
   return DOCUMENTS.has(identifier);
@@ -499,6 +147,7 @@ function freeze(obj) {
 
 // type IdentifierTypeLookup = { all: Set<StableRecordIdentifier>; id: Map<string, StableRecordIdentifier> };
 // type IdentifiersByType = Map<string, IdentifierTypeLookup>;
+
 let configuredForgetMethod;
 let configuredGenerationMethod;
 let configuredResetMethod;
@@ -519,6 +168,7 @@ function setIdentifierResetMethod(method) {
 // Map<type, Map<id, lid>>
 
 const NEW_IDENTIFIERS = new Map();
+let IDENTIFIER_CACHE_ID = 0;
 function updateTypeIdMapping(typeMap, identifier, id) {
   let idMap = typeMap.get(identifier.type);
   if (!idMap) {
@@ -601,10 +251,12 @@ class IdentifierCache {
     this._merge = defaultMergeMethod;
     this._keyInfoForResource = defaultKeyInfoMethod;
     this._isDefaultConfig = !configuredGenerationMethod;
+    this._id = IDENTIFIER_CACHE_ID++;
     this._cache = {
       resources: new Map(),
       resourcesByType: Object.create(null),
-      documents: new Map()
+      documents: new Map(),
+      polymorphicLidBackMap: new Map()
     };
   }
 
@@ -658,7 +310,7 @@ class IdentifierCache {
       console.log(`Identifiers: ${lid ? 'no ' : ''}lid ${lid ? lid + ' ' : ''}determined for resource`, resource);
     }
     let identifier = /*#__NOINLINE__*/getIdentifierFromLid(this._cache, lid, resource);
-    if (identifier !== undefined) {
+    if (identifier !== null) {
       if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
         // eslint-disable-next-line no-console
         console.groupEnd();
@@ -676,11 +328,13 @@ class IdentifierCache {
     // if we still don't have an identifier, time to generate one
     if (shouldGenerate === 2) {
       resource.lid = lid;
+      resource[CACHE_OWNER] = this._id;
       identifier = /*#__NOINLINE__*/makeStableRecordIdentifier(resource, 'record', false);
     } else {
       // we lie a bit here as a memory optimization
       const keyInfo = this._keyInfoForResource(resource, null);
       keyInfo.lid = lid;
+      keyInfo[CACHE_OWNER] = this._id;
       identifier = /*#__NOINLINE__*/makeStableRecordIdentifier(keyInfo, 'record', false);
     }
     addResourceToCache(this._cache, identifier);
@@ -698,7 +352,7 @@ class IdentifierCache {
    *
    * @method peekRecordIdentifier
    * @param resource
-   * @returns {StableRecordIdentifier | undefined}
+   * @return {StableRecordIdentifier | undefined}
    * @private
    */
   peekRecordIdentifier(resource) {
@@ -710,7 +364,7 @@ class IdentifierCache {
     Returns `null` if the request does not have a `cacheKey` or `url`.
      @method getOrCreateDocumentIdentifier
     @param request
-    @returns {StableDocumentIdentifier | null}
+    @return {StableDocumentIdentifier | null}
     @public
   */
   getOrCreateDocumentIdentifier(request) {
@@ -744,7 +398,7 @@ class IdentifierCache {
     - this referential stability of the object itself is guaranteed
      @method getOrCreateRecordIdentifier
     @param resource
-    @returns {StableRecordIdentifier}
+    @return {StableRecordIdentifier}
     @public
   */
   getOrCreateRecordIdentifier(resource) {
@@ -759,15 +413,16 @@ class IdentifierCache {
    with the signature `generateMethod({ type }, 'record')`.
     @method createIdentifierForNewRecord
    @param data
-   @returns {StableRecordIdentifier}
+   @return {StableRecordIdentifier}
    @public
   */
   createIdentifierForNewRecord(data) {
-    let newLid = this._generate(data, 'record');
-    let identifier = /*#__NOINLINE__*/makeStableRecordIdentifier({
+    const newLid = this._generate(data, 'record');
+    const identifier = /*#__NOINLINE__*/makeStableRecordIdentifier({
       id: data.id || null,
       type: data.type,
-      lid: newLid
+      lid: newLid,
+      [CACHE_OWNER]: this._id
     }, 'record', true);
 
     // populate our unique table
@@ -801,7 +456,7 @@ class IdentifierCache {
      @method updateRecordIdentifier
     @param identifierObject
     @param data
-    @returns {StableRecordIdentifier}
+    @return {StableRecordIdentifier}
     @public
   */
   updateRecordIdentifier(identifierObject, data) {
@@ -821,7 +476,7 @@ class IdentifierCache {
       }
     }
     if (existingIdentifier) {
-      let generatedIdentifier = identifier;
+      const generatedIdentifier = identifier;
       identifier = this._mergeRecordIdentifiers(keyInfo, generatedIdentifier, existingIdentifier, data);
 
       // make sure that the `lid` on the data we are processing matches the lid we kept
@@ -833,7 +488,7 @@ class IdentifierCache {
         console.log(`Identifiers: merged identifiers ${generatedIdentifier.lid} and ${existingIdentifier.lid} for resource into ${identifier.lid}`, data);
       }
     }
-    let id = identifier.id;
+    const id = identifier.id;
     /*#__NOINLINE__*/
     performRecordIdentifierUpdate(identifier, keyInfo, data, this._update);
     const newId = identifier.id;
@@ -867,16 +522,32 @@ class IdentifierCache {
     const kept = this._merge(identifier, existingIdentifier, data);
     const abandoned = kept === identifier ? existingIdentifier : identifier;
 
+    // get any backreferences before forgetting this identifier, as it will be removed from the cache
+    // and we will no longer be able to find them
+    const abandonedBackReferences = this._cache.polymorphicLidBackMap.get(abandoned.lid);
+    // delete the backreferences for the abandoned identifier so that forgetRecordIdentifier
+    // does not try to remove them.
+    if (abandonedBackReferences) this._cache.polymorphicLidBackMap.delete(abandoned.lid);
+
     // cleanup the identifier we no longer need
     this.forgetRecordIdentifier(abandoned);
 
-    // ensure a secondary cache entry for this id for the identifier we do keep
-    // keyOptions.id.set(newId, kept);
+    // ensure a secondary cache entry for the original lid for the abandoned identifier
+    this._cache.resources.set(abandoned.lid, kept);
 
-    // ensure a secondary cache entry for this id for the abandoned identifier's type we do keep
-    // let baseKeyOptions = getTypeIndex(this._cache.resourcesByType, existingIdentifier.type);
-    // baseKeyOptions.id.set(newId, kept);
+    // backReferences let us know which other identifiers are pointing at this identifier
+    // so we can delete them later if we forget this identifier
+    const keptBackReferences = this._cache.polymorphicLidBackMap.get(kept.lid) ?? [];
+    keptBackReferences.push(abandoned.lid);
 
+    // update the backreferences from the abandoned identifier to be for the kept identifier
+    if (abandonedBackReferences) {
+      abandonedBackReferences.forEach(lid => {
+        keptBackReferences.push(lid);
+        this._cache.resources.set(lid, kept);
+      });
+    }
+    this._cache.polymorphicLidBackMap.set(kept.lid, keptBackReferences);
     return kept;
   }
 
@@ -899,6 +570,17 @@ class IdentifierCache {
     }
     this._cache.resources.delete(identifier.lid);
     typeSet.lid.delete(identifier.lid);
+    const backReferences = this._cache.polymorphicLidBackMap.get(identifier.lid);
+    if (backReferences) {
+      backReferences.forEach(lid => {
+        this._cache.resources.delete(lid);
+      });
+      this._cache.polymorphicLidBackMap.delete(identifier.lid);
+    }
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
+      identifier[DEBUG_STALE_CACHE_OWNER] = identifier[CACHE_OWNER];
+    }
+    identifier[CACHE_OWNER] = undefined;
     IDENTIFIERS.delete(identifier);
     this._forget(identifier, 'record');
     if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
@@ -929,15 +611,33 @@ function makeStableRecordIdentifier(recordIdentifier, bucket, clientOriginated)
       get type() {
         return recordIdentifier.type;
       },
-      toString() {
+      get [CACHE_OWNER]() {
+        return recordIdentifier[CACHE_OWNER];
+      },
+      set [CACHE_OWNER](value) {
+        recordIdentifier[CACHE_OWNER] = value;
+      },
+      get [DEBUG_STALE_CACHE_OWNER]() {
+        return recordIdentifier[DEBUG_STALE_CACHE_OWNER];
+      },
+      set [DEBUG_STALE_CACHE_OWNER](value) {
+        recordIdentifier[DEBUG_STALE_CACHE_OWNER] = value;
+      }
+    };
+    Object.defineProperty(wrapper, 'toString', {
+      enumerable: false,
+      value: () => {
         const {
           type,
           id,
           lid
         } = recordIdentifier;
         return `${clientOriginated ? '[CLIENT_ORIGINATED] ' : ''}${String(type)}:${String(id)} (${lid})`;
-      },
-      toJSON() {
+      }
+    });
+    Object.defineProperty(wrapper, 'toJSON', {
+      enumerable: false,
+      value: () => {
         const {
           type,
           id,
@@ -949,7 +649,7 @@ function makeStableRecordIdentifier(recordIdentifier, bucket, clientOriginated)
           lid
         };
       }
-    };
+    });
     wrapper[DEBUG_CLIENT_ORIGINATED] = clientOriginated;
     wrapper[DEBUG_IDENTIFIER_BUCKET] = bucket;
     IDENTIFIERS.add(wrapper);
@@ -967,7 +667,7 @@ function performRecordIdentifierUpdate(identifier, keyInfo, data, updateFn) {
     } = keyInfo;
 
     // get the mutable instance behind our proxy wrapper
-    let wrapper = identifier;
+    const wrapper = identifier;
     identifier = DEBUG_MAP.get(wrapper);
     if (hasLid(data)) {
       const lid = data.lid;
@@ -1022,7 +722,7 @@ function detectMerge(cache, keyInfo, identifier, data) {
     // we trigger a merge of the identifiers
     // though probably we should just throw an error here
     if (id !== null && id === newId && newType === type && hasLid(data) && data.lid !== lid) {
-      return cache.resources.get(data.lid) || false;
+      return getIdentifierFromLid(cache, data.lid, data) || false;
 
       // If the lids are the same, and ids are the same, but types are different we should trigger a merge of the identifiers
     } else if (id !== null && id === newId && newType && newType !== type && hasLid(data) && data.lid === lid) {
@@ -1039,7 +739,7 @@ function getIdentifierFromLid(cache, lid, resource) {
     // eslint-disable-next-line no-console
     console.log(`Identifiers: cache ${identifier ? 'HIT' : 'MISS'} - Non-Stable ${lid}`, resource);
   }
-  return identifier;
+  return identifier || null;
 }
 function addResourceToCache(cache, identifier) {
   cache.resources.set(identifier.lid, identifier);
@@ -1056,28 +756,27 @@ function addResourceToCache(cache, identifier) {
     typeSet.id.set(identifier.id, identifier);
   }
 }
-var _class$1, _descriptor$1;
 
 /**
   @module @ember-data/store
 */
+
 /**
   @module @ember-data/store
 */
+
 /**
    A `RecordReference` is a low-level API that allows users and
    addon authors to perform meta-operations on a record.
 
    @class RecordReference
    @public
-   @extends Reference
 */
-let RecordReference = (_class$1 = class RecordReference {
+class RecordReference {
   constructor(store, identifier) {
     // unsubscribe token given to us by the notification manager
     this.___token = void 0;
     this.___identifier = void 0;
-    _initializerDefineProperty(this, "_ref", _descriptor$1, this);
     this.store = store;
     this.___identifier = identifier;
     this.___token = store.notifications.subscribe(identifier, (_, bucket, notifiedKey) => {
@@ -1245,14 +944,8 @@ let RecordReference = (_class$1 = class RecordReference {
     }
     assert(`Unable to fetch record of type ${this.type} without an id`);
   }
-}, _descriptor$1 = _applyDecoratedDescriptor(_class$1.prototype, "_ref", [tracked], {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  initializer: function () {
-    return 0;
-  }
-}), _class$1);
+}
+defineSignal(RecordReference.prototype, '_ref');
 
 /**
   @module @ember-data/store
@@ -1283,6 +976,8 @@ class CacheCapabilitiesManager {
     if (this._store._cbs) {
       this._store._schedule('notify', () => this._flushNotifications());
     } else {
+      // TODO @runspired determine if relationship mutations should schedule
+      // into join/run vs immediate flush
       this._flushNotifications();
     }
   }
@@ -1290,7 +985,7 @@ class CacheCapabilitiesManager {
     if (this._willNotify === false) {
       return;
     }
-    let pending = this._pendingNotifies;
+    const pending = this._pendingNotifies;
     this._pendingNotifies = new Map();
     this._willNotify = false;
     pending.forEach((set, identifier) => {
@@ -1314,6 +1009,9 @@ class CacheCapabilitiesManager {
   getSchemaDefinitionService() {
     return this._store.getSchemaDefinitionService();
   }
+  get schema() {
+    return this._store.schema;
+  }
   setRecordId(identifier, id) {
     assert(`Expected a stable identifier`, isStableIdentifier(identifier));
     this._store._instanceCache.setRecordId(identifier, id);
@@ -1347,6 +1045,9 @@ function peekCache(instance) {
   }
   return null;
 }
+function isDestroyable(record) {
+  return Boolean(record && typeof record === 'object' && typeof record.destroy === 'function');
+}
 
 /**
   @module @ember-data/store
@@ -1374,8 +1075,9 @@ function peekRecordIdentifier(record) {
   @static
   @for @ember-data/store
   @param {Object} record a record instance previously obstained from the store.
-  @returns {StableRecordIdentifier}
+  @return {StableRecordIdentifier}
  */
+
 function recordIdentifierFor(record) {
   assert(`${String(record)} is not a record instantiated by @ember-data/store`, RecordCache.has(record));
   return RecordCache.get(record);
@@ -1421,11 +1123,11 @@ class InstanceCache {
         // @ts-expect-error TODO this needs to be fixed
         'type' in resourceData && identifier.type === resourceData.type ? identifier : matchedIdentifier;
       }
-      let staleIdentifier = identifier === keptIdentifier ? matchedIdentifier : identifier;
+      const staleIdentifier = identifier === keptIdentifier ? matchedIdentifier : identifier;
 
       // check for duplicate entities
-      let keptHasRecord = this.__instances.record.has(keptIdentifier);
-      let staleHasRecord = this.__instances.record.has(staleIdentifier);
+      const keptHasRecord = this.__instances.record.has(keptIdentifier);
+      const staleHasRecord = this.__instances.record.has(staleIdentifier);
 
       // we cannot merge entities when both have records
       // (this may not be strictly true, we could probably swap the cache data the record points at)
@@ -1479,7 +1181,7 @@ class InstanceCache {
     return record;
   }
   getReference(identifier) {
-    let cache = this.__instances.reference;
+    const cache = this.__instances.reference;
     let reference = cache.get(identifier);
     if (!reference) {
       reference = new RecordReference(this.store, identifier);
@@ -1510,7 +1212,7 @@ class InstanceCache {
   }
   disconnect(identifier) {
     const record = this.__instances.record.get(identifier);
-    assert('Cannot destroy record while it is still materialized', !record || record.isDestroyed || record.isDestroying);
+    assert('Cannot destroy record while it is still materialized', !isDestroyable(record) || record.isDestroyed || record.isDestroying);
     this.store._graph?.remove(identifier);
     this.store.identifierCache.forgetRecordIdentifier(identifier);
     removeRecordDataFor(identifier);
@@ -1578,7 +1280,7 @@ class InstanceCache {
       });
     } else {
       const typeCache = cache.resourcesByType;
-      let identifiers = typeCache[type]?.lid;
+      const identifiers = typeCache[type]?.lid;
       if (identifiers) {
         identifiers.forEach(identifier => {
           // if (rds.has(identifier)) {
@@ -1596,7 +1298,7 @@ class InstanceCache {
       type,
       lid
     } = identifier;
-    let oldId = identifier.id;
+    const oldId = identifier.id;
 
     // ID absolutely can't be missing if the oldID is empty (missing Id in response for a new record)
     assert(`'${type}' was saved to the server, but the response does not have an id and your record does not either.`, !(id === null && oldId === null));
@@ -1615,7 +1317,7 @@ class InstanceCache {
       // eslint-disable-next-line no-console
       console.log(`InstanceCache: updating id to '${id}' for record ${String(identifier)}`);
     }
-    let existingIdentifier = this.store.identifierCache.peekRecordIdentifier({
+    const existingIdentifier = this.store.identifierCache.peekRecordIdentifier({
       type,
       id
     });
@@ -1654,13 +1356,13 @@ function resourceIsFullyDeleted(instanceCache, identifier) {
   */
 
 function preloadData(store, identifier, preload) {
-  let jsonPayload = {};
+  const jsonPayload = {};
   //TODO(Igor) consider the polymorphic case
   const schemas = store.getSchemaDefinitionService();
   const relationships = schemas.relationshipsDefinitionFor(identifier);
   Object.keys(preload).forEach(key => {
-    let preloadValue = preload[key];
-    let relationshipMeta = relationships[key];
+    const preloadValue = preload[key];
+    const relationshipMeta = relationships[key];
     if (relationshipMeta) {
       if (!jsonPayload.relationships) {
         jsonPayload.relationships = {};
@@ -1729,7 +1431,7 @@ function getShimClass(store, modelName) {
 }
 function mapFromHash(hash) {
   const map = new Map();
-  for (let i in hash) {
+  for (const i in hash) {
     if (Object.prototype.hasOwnProperty.call(hash, i)) {
       map.set(i, hash[i]);
     }
@@ -1744,31 +1446,31 @@ class ShimModelClass {
     this.modelName = modelName;
   }
   get fields() {
-    let attrs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
+    const attrs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
       type: this.modelName
     });
-    let relationships = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({
+    const relationships = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({
       type: this.modelName
     });
-    let fields = new Map();
+    const fields = new Map();
     Object.keys(attrs).forEach(key => fields.set(key, 'attribute'));
     Object.keys(relationships).forEach(key => fields.set(key, relationships[key].kind));
     return fields;
   }
   get attributes() {
-    let attrs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
+    const attrs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
       type: this.modelName
     });
     return mapFromHash(attrs);
   }
   get relationshipsByName() {
-    let relationships = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({
+    const relationships = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({
       type: this.modelName
     });
     return mapFromHash(relationships);
   }
   eachAttribute(callback, binding) {
-    let attrDefs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
+    const attrDefs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
       type: this.modelName
     });
     Object.keys(attrDefs).forEach(key => {
@@ -1776,7 +1478,7 @@ class ShimModelClass {
     });
   }
   eachRelationship(callback, binding) {
-    let relationshipDefs = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({
+    const relationshipDefs = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({
       type: this.modelName
     });
     Object.keys(relationshipDefs).forEach(key => {
@@ -1794,6 +1496,16 @@ class ShimModelClass {
     });
   }
 }
+function _classPrivateFieldBase(receiver, privateKey) {
+  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+    throw new TypeError("attempted to use private field on non-instance");
+  }
+  return receiver;
+}
+var id = 0;
+function _classPrivateFieldKey(name) {
+  return "__private_" + id++ + "_" + name;
+}
 var _cache = /*#__PURE__*/_classPrivateFieldKey("cache");
 /**
  * The CacheManager wraps a Cache enforcing that only
@@ -1820,16 +1532,6 @@ class CacheManager {
       writable: true,
       value: void 0
     });
-    /**
-     * Query the cache for whether a given resource has been deleted and that deletion
-     * has also been persisted.
-     *
-     * @method isDeletionCommitted
-     * @public
-     * @param identifier
-     * @returns {boolean}
-     */
-    this.isDel = void 0;
     _classPrivateFieldBase(this, _cache)[_cache] = cache;
   }
 
@@ -1843,7 +1545,7 @@ class CacheManager {
    * semantics, `put` has `replace` semantics similar to
    * the `http` method `PUT`
    *
-   * the individually cacheabl
+   * the individually cacheable
    * e resource data it may contain
    * should upsert, but the document data surrounding it should
    * fully replace any existing information
@@ -1856,7 +1558,7 @@ class CacheManager {
    *
    * @method put
    * @param {StructuredDocument} doc
-   * @returns {ResourceDocument}
+   * @return {ResourceDocument}
    * @public
    */
   put(doc) {
@@ -1872,7 +1574,7 @@ class CacheManager {
    * @method patch
    * @public
    * @param op the operation to perform
-   * @returns {void}
+   * @return {void}
    */
   patch(op) {
     _classPrivateFieldBase(this, _cache)[_cache].patch(op);
@@ -1907,7 +1609,7 @@ class CacheManager {
    * An implementation might want to do this because
    * de-referencing records which read from their own
    * blob is generally safer because the record does
-   * not require retainining connections to the Store
+   * not require retaining connections to the Store
    * and Cache to present data on a per-field basis.
    *
    * This generally takes the place of `getAttr` as
@@ -1920,7 +1622,7 @@ class CacheManager {
    * @method peek
    * @public
    * @param {StableRecordIdentifier | StableDocumentIdentifier} identifier
-   * @returns {ResourceDocument | ResourceBlob | null} the known resource data
+   * @return {ResourceDocument | ResourceBlob | null} the known resource data
    */
 
   peek(identifier) {
@@ -1933,7 +1635,7 @@ class CacheManager {
    *
    * @method peekRequest
    * @param {StableDocumentIdentifier}
-   * @returns {StableDocumentIdentifier | null}
+   * @return {StableDocumentIdentifier | null}
    * @public
    */
   peekRequest(identifier) {
@@ -1948,7 +1650,7 @@ class CacheManager {
    * @param identifier
    * @param data
    * @param hasRecord
-   * @returns {void | string[]} if `hasRecord` is true then calculated key changes should be returned
+   * @return {void | string[]} if `hasRecord` is true then calculated key changes should be returned
    */
   upsert(identifier, data, hasRecord) {
     return _classPrivateFieldBase(this, _cache)[_cache].upsert(identifier, data, hasRecord);
@@ -1966,7 +1668,7 @@ class CacheManager {
    *
    * @method fork
    * @public
-   * @returns Promise<Cache>
+   * @return Promise<Cache>
    */
   fork() {
     return _classPrivateFieldBase(this, _cache)[_cache].fork();
@@ -1982,7 +1684,7 @@ class CacheManager {
    * @method merge
    * @param {Cache} cache
    * @public
-   * @returns Promise<void>
+   * @return Promise<void>
    */
   merge(cache) {
     return _classPrivateFieldBase(this, _cache)[_cache].merge(cache);
@@ -2034,7 +1736,7 @@ class CacheManager {
    * via `cache.hydrate`.
    *
    * @method dump
-   * @returns {Promise<ReadableStream>}
+   * @return {Promise<ReadableStream>}
    * @public
    */
   dump() {
@@ -2055,7 +1757,7 @@ class CacheManager {
    *
    * @method hydrate
    * @param {ReadableStream} stream
-   * @returns {Promise<void>}
+   * @return {Promise<void>}
    * @public
    */
   hydrate(stream) {
@@ -2069,7 +1771,7 @@ class CacheManager {
   // ================
 
   /**
-   * [LIFECYLCE] Signal to the cache that a new record has been instantiated on the client
+   * [LIFECYCLE] Signal to the cache that a new record has been instantiated on the client
    *
    * It returns properties from options that should be set on the record during the create
    * process. This return value behavior is deprecated.
@@ -2143,7 +1845,7 @@ class CacheManager {
    * @public
    * @param identifier
    * @param propertyName
-   * @returns {unknown}
+   * @return {unknown}
    */
   getAttr(identifier, propertyName) {
     return _classPrivateFieldBase(this, _cache)[_cache].getAttr(identifier, propertyName);
@@ -2168,7 +1870,7 @@ class CacheManager {
    * @method changedAttrs
    * @public
    * @param identifier
-   * @returns
+   * @return
    */
   changedAttrs(identifier) {
     return _classPrivateFieldBase(this, _cache)[_cache].changedAttrs(identifier);
@@ -2180,7 +1882,7 @@ class CacheManager {
    * @method hasChangedAttrs
    * @public
    * @param identifier
-   * @returns {boolean}
+   * @return {boolean}
    */
   hasChangedAttrs(identifier) {
     return _classPrivateFieldBase(this, _cache)[_cache].hasChangedAttrs(identifier);
@@ -2192,7 +1894,7 @@ class CacheManager {
    * @method rollbackAttrs
    * @public
    * @param identifier
-   * @returns the names of attributes that were restored
+   * @return the names of attributes that were restored
    */
   rollbackAttrs(identifier) {
     return _classPrivateFieldBase(this, _cache)[_cache].rollbackAttrs(identifier);
@@ -2201,6 +1903,65 @@ class CacheManager {
   // Relationships
   // =============
 
+  /**
+   * Query the cache for the changes to relationships of a resource.
+   *
+   * Returns a map of relationship names to RelationshipDiff objects.
+   *
+   * ```ts
+   * type RelationshipDiff =
+  | {
+      kind: 'collection';
+      remoteState: StableRecordIdentifier[];
+      additions: Set<StableRecordIdentifier>;
+      removals: Set<StableRecordIdentifier>;
+      localState: StableRecordIdentifier[];
+      reordered: boolean;
+    }
+  | {
+      kind: 'resource';
+      remoteState: StableRecordIdentifier | null;
+      localState: StableRecordIdentifier | null;
+    };
+    ```
+   *
+   * @method changedRelationships
+   * @public
+   * @param {StableRecordIdentifier} identifier
+   * @return {Map<string, RelationshipDiff>}
+   */
+  changedRelationships(identifier) {
+    return _classPrivateFieldBase(this, _cache)[_cache].changedRelationships(identifier);
+  }
+
+  /**
+   * Query the cache for whether any mutated attributes exist
+   *
+   * @method hasChangedRelationships
+   * @public
+   * @param {StableRecordIdentifier} identifier
+   * @return {boolean}
+   */
+  hasChangedRelationships(identifier) {
+    return _classPrivateFieldBase(this, _cache)[_cache].hasChangedRelationships(identifier);
+  }
+
+  /**
+   * Tell the cache to discard any uncommitted mutations to relationships.
+   *
+   * This will also discard the change on any appropriate inverses.
+   *
+   * This method is a candidate to become a mutation
+   *
+   * @method rollbackRelationships
+   * @public
+   * @param {StableRecordIdentifier} identifier
+   * @return {string[]} the names of relationships that were restored
+   */
+  rollbackRelationships(identifier) {
+    return _classPrivateFieldBase(this, _cache)[_cache].rollbackRelationships(identifier);
+  }
+
   /**
    * Query the cache for the current state of a relationship property
    *
@@ -2208,7 +1969,7 @@ class CacheManager {
    * @public
    * @param identifier
    * @param propertyName
-   * @returns resource relationship object
+   * @return resource relationship object
    */
   getRelationship(identifier, propertyName) {
     return _classPrivateFieldBase(this, _cache)[_cache].getRelationship(identifier, propertyName);
@@ -2236,7 +1997,7 @@ class CacheManager {
    * @method getErrors
    * @public
    * @param identifier
-   * @returns
+   * @return
    */
   getErrors(identifier) {
     return _classPrivateFieldBase(this, _cache)[_cache].getErrors(identifier);
@@ -2248,7 +2009,7 @@ class CacheManager {
    * @method isEmpty
    * @public
    * @param identifier
-   * @returns {boolean}
+   * @return {boolean}
    */
   isEmpty(identifier) {
     return _classPrivateFieldBase(this, _cache)[_cache].isEmpty(identifier);
@@ -2261,7 +2022,7 @@ class CacheManager {
    * @method isNew
    * @public
    * @param identifier
-   * @returns {boolean}
+   * @return {boolean}
    */
   isNew(identifier) {
     return _classPrivateFieldBase(this, _cache)[_cache].isNew(identifier);
@@ -2274,15 +2035,29 @@ class CacheManager {
    * @method isDeleted
    * @public
    * @param identifier
-   * @returns {boolean}
+   * @return {boolean}
    */
   isDeleted(identifier) {
     return _classPrivateFieldBase(this, _cache)[_cache].isDeleted(identifier);
   }
+
+  /**
+   * Query the cache for whether a given resource has been deleted and that deletion
+   * has also been persisted.
+   *
+   * @method isDeletionCommitted
+   * @public
+   * @param identifier
+   * @return {boolean}
+   */
   isDeletionCommitted(identifier) {
     return _classPrivateFieldBase(this, _cache)[_cache].isDeletionCommitted(identifier);
   }
 }
+
+/**
+ * @module @ember-data/store
+ */
 let tokenId = 0;
 const CacheOperations = new Set(['added', 'removed', 'state', 'updated']);
 function isCacheOperationValue(value) {
@@ -2293,7 +2068,7 @@ function runLoopIsFlushing() {
   return !!_backburner.currentInstance && _backburner._autorun !== true;
 }
 function _unsubscribe(tokens, token, cache) {
-  let identifier = tokens.get(token);
+  const identifier = tokens.get(token);
   if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
     if (!identifier) {
       // eslint-disable-next-line no-console
@@ -2352,7 +2127,7 @@ class NotificationManager {
    * @public
    * @param {StableDocumentIdentifier | StableRecordIdentifier | 'resource' | 'document'} identifier
    * @param {NotificationCallback | ResourceOperationCallback | DocumentOperationCallback} callback
-   * @returns {UnsubscribeToken} an opaque token to be used with unsubscribe
+   * @return {UnsubscribeToken} an opaque token to be used with unsubscribe
    */
 
   subscribe(identifier, callback) {
@@ -2362,7 +2137,7 @@ class NotificationManager {
       map = new Map();
       this._cache.set(identifier, map);
     }
-    let unsubToken = macroCondition(getOwnConfig().env.DEBUG) ? {
+    const unsubToken = macroCondition(getOwnConfig().env.DEBUG) ? {
       _tokenRef: tokenId++
     } : {};
     map.set(unsubToken, callback);
@@ -2415,7 +2190,7 @@ class NotificationManager {
         this._buffered.set(identifier, buffer);
       }
       buffer.push([value, key]);
-      void this._scheduleNotify();
+      this._scheduleNotify();
     }
     return hasSubscribers;
   }
@@ -2457,14 +2232,14 @@ class NotificationManager {
 
     // TODO for documents this will need to switch based on Identifier kind
     if (isCacheOperationValue(value)) {
-      let callbackMap = this._cache.get(isDocumentIdentifier(identifier) ? 'document' : 'resource');
+      const callbackMap = this._cache.get(isDocumentIdentifier(identifier) ? 'document' : 'resource');
       if (callbackMap) {
         callbackMap.forEach(cb => {
           cb(identifier, value);
         });
       }
     }
-    let callbackMap = this._cache.get(identifier);
+    const callbackMap = this._cache.get(identifier);
     if (!callbackMap || !callbackMap.size) {
       return false;
     }
@@ -2480,7 +2255,30 @@ class NotificationManager {
     this._cache.clear();
   }
 }
-var _class, _descriptor, _class3, _descriptor2;
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
+  var desc = {};
+  Object.keys(descriptor).forEach(function (key) {
+    desc[key] = descriptor[key];
+  });
+  desc.enumerable = !!desc.enumerable;
+  desc.configurable = !!desc.configurable;
+  if ('value' in desc || desc.initializer) {
+    desc.writable = true;
+  }
+  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
+    return decorator(target, property, desc) || desc;
+  }, desc);
+  if (context && desc.initializer !== void 0) {
+    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+    desc.initializer = undefined;
+  }
+  if (desc.initializer === void 0) {
+    Object.defineProperty(target, property, desc);
+    desc = null;
+  }
+  return desc;
+}
+var _class;
 const ARRAY_GETTER_METHODS = new Set([Symbol.iterator, 'concat', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'flat', 'flatMap', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'map', 'reduce', 'reduceRight', 'slice', 'some', 'values']);
 const ARRAY_SETTER_METHODS = new Set(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
 const SYNC_PROPS = new Set(['[]', 'length', 'links', 'meta']);
@@ -2490,19 +2288,16 @@ function isArrayGetter(prop) {
 function isArraySetter(prop) {
   return ARRAY_SETTER_METHODS.has(prop);
 }
-const IDENTIFIER_ARRAY_TAG = Symbol('#tag');
+function isSelfProp(self, prop) {
+  return prop in self;
+}
+const ARRAY_SIGNAL = Symbol('#signal');
 const SOURCE = Symbol('#source');
 const MUTATE = Symbol('#update');
 const NOTIFY = Symbol('#notify');
 const IS_COLLECTION = Symbol.for('Collection');
 function notifyArray(arr) {
-  addToTransaction(arr[IDENTIFIER_ARRAY_TAG]);
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_COMPUTED_CHAINS)) {
-    // eslint-disable-next-line
-    dirtyTag(tagForProperty(arr, 'length'));
-    // eslint-disable-next-line
-    dirtyTag(tagForProperty(arr, '[]'));
-  }
+  addToTransaction(arr[ARRAY_SIGNAL]);
 }
 function convertToInt(prop) {
   if (typeof prop === 'symbol') return null;
@@ -2510,29 +2305,6 @@ function convertToInt(prop) {
   if (isNaN(num)) return null;
   return num % 1 === 0 ? num : null;
 }
-let Tag = (_class = class Tag {
-  /*
-   * whether this was part of a transaction when last mutated
-   */
-
-  constructor() {
-    _initializerDefineProperty(this, "ref", _descriptor, this);
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
-      const [arr, prop] = arguments;
-      this._debug_base = arr.constructor.name + ':' + String(arr.modelName);
-      this._debug_prop = prop;
-    }
-    this.shouldReset = false;
-    this.t = false;
-  }
-}, _descriptor = _applyDecoratedDescriptor(_class.prototype, "ref", [tracked], {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  initializer: function () {
-    return null;
-  }
-}), _class);
 function safeForEach(instance, arr, store, callback, target) {
   if (target === undefined) {
     target = null;
@@ -2565,7 +2337,7 @@ function safeForEach(instance, arr, store, callback, target) {
   @class RecordArray
   @public
 */
-let IdentifierArray = (_class3 = class IdentifierArray {
+let IdentifierArray = (_class = class IdentifierArray {
   [NOTIFY]() {
     notifyArray(this);
   }
@@ -2593,14 +2365,6 @@ let IdentifierArray = (_class3 = class IdentifierArray {
   set length(value) {
     this[SOURCE].length = value;
   }
-
-  // here to support computed chains
-  // and {{#each}}
-  get '[]'() {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_COMPUTED_CHAINS)) {
-      return this;
-    }
-  }
   constructor(options) {
     /**
       The flag to signal a `RecordArray` is currently loading data.
@@ -2615,7 +2379,6 @@ let IdentifierArray = (_class3 = class IdentifierArray {
       @public
       @type Boolean
     */
-    _initializerDefineProperty(this, "isUpdating", _descriptor2, this);
     this.isLoaded = true;
     this.isDestroying = false;
     this.isDestroyed = false;
@@ -2623,16 +2386,15 @@ let IdentifierArray = (_class3 = class IdentifierArray {
     this[IS_COLLECTION] = true;
     this[SOURCE] = void 0;
     // eslint-disable-next-line @typescript-eslint/no-this-alias
-    let self = this;
+    const self = this;
     this.modelName = options.type;
     this.store = options.store;
     this._manager = options.manager;
     this[SOURCE] = options.identifiers;
-    // @ts-expect-error
-    this[IDENTIFIER_ARRAY_TAG] = macroCondition(getOwnConfig().env.DEBUG) ? new Tag(this, 'length') : new Tag();
+    this[ARRAY_SIGNAL] = createSignal(this, 'length');
     const store = options.store;
     const boundFns = new Map();
-    const _TAG = this[IDENTIFIER_ARRAY_TAG];
+    const _SIGNAL = this[ARRAY_SIGNAL];
     const PrivateState = {
       links: options.links || null,
       meta: options.meta || null
@@ -2645,40 +2407,40 @@ let IdentifierArray = (_class3 = class IdentifierArray {
 
     const proxy = new Proxy(this[SOURCE], {
       get(target, prop, receiver) {
-        let index = convertToInt(prop);
-        if (_TAG.shouldReset && (index !== null || SYNC_PROPS.has(prop) || isArrayGetter(prop))) {
+        const index = convertToInt(prop);
+        if (_SIGNAL.shouldReset && (index !== null || SYNC_PROPS.has(prop) || isArrayGetter(prop))) {
           options.manager._syncArray(receiver);
-          _TAG.t = false;
-          _TAG.shouldReset = false;
+          _SIGNAL.t = false;
+          _SIGNAL.shouldReset = false;
         }
         if (index !== null) {
           const identifier = target[index];
           if (!transaction) {
-            subscribe(_TAG);
+            subscribe(_SIGNAL);
           }
           return identifier && store._instanceCache.getRecord(identifier);
         }
-        if (prop === 'meta') return subscribe(_TAG), PrivateState.meta;
-        if (prop === 'links') return subscribe(_TAG), PrivateState.links;
-        if (prop === '[]') return subscribe(_TAG), receiver;
+        if (prop === 'meta') return subscribe(_SIGNAL), PrivateState.meta;
+        if (prop === 'links') return subscribe(_SIGNAL), PrivateState.links;
+        if (prop === '[]') return subscribe(_SIGNAL), receiver;
         if (isArrayGetter(prop)) {
           let fn = boundFns.get(prop);
           if (fn === undefined) {
             if (prop === 'forEach') {
               fn = function () {
-                subscribe(_TAG);
+                subscribe(_SIGNAL);
                 transaction = true;
-                let result = safeForEach(receiver, target, store, arguments[0], arguments[1]);
+                const result = safeForEach(receiver, target, store, arguments[0], arguments[1]);
                 transaction = false;
                 return result;
               };
             } else {
               fn = function () {
-                subscribe(_TAG);
+                subscribe(_SIGNAL);
                 // array functions must run through Reflect to work properly
                 // binding via other means will not work.
                 transaction = true;
-                let result = Reflect.apply(target[prop], receiver, arguments);
+                const result = Reflect.apply(target[prop], receiver, arguments);
                 transaction = false;
                 return result;
               };
@@ -2700,10 +2462,7 @@ let IdentifierArray = (_class3 = class IdentifierArray {
               const args = Array.prototype.slice.call(arguments);
               assert(`Cannot start a new array transaction while a previous transaction is underway`, !transaction);
               transaction = true;
-              let result = Reflect.apply(target[prop], receiver, args);
-              self[MUTATE](prop, args, result);
-              addToTransaction(_TAG);
-              // TODO handle cache updates
+              const result = self[MUTATE](target, receiver, prop, args, _SIGNAL);
               transaction = false;
               return result;
             };
@@ -2711,16 +2470,16 @@ let IdentifierArray = (_class3 = class IdentifierArray {
           }
           return fn;
         }
-        if (prop in self) {
-          if (prop === NOTIFY || prop === IDENTIFIER_ARRAY_TAG || prop === SOURCE) {
+        if (isSelfProp(self, prop)) {
+          if (prop === NOTIFY || prop === ARRAY_SIGNAL || prop === SOURCE) {
             return self[prop];
           }
           let fn = boundFns.get(prop);
           if (fn) return fn;
-          let outcome = self[prop];
+          const outcome = self[prop];
           if (typeof outcome === 'function') {
             fn = function () {
-              subscribe(_TAG);
+              subscribe(_SIGNAL);
               // array functions must run through Reflect to work properly
               // binding via other means will not work.
               return Reflect.apply(outcome, receiver, arguments);
@@ -2728,17 +2487,16 @@ let IdentifierArray = (_class3 = class IdentifierArray {
             boundFns.set(prop, fn);
             return fn;
           }
-          return subscribe(_TAG), outcome;
+          return subscribe(_SIGNAL), outcome;
         }
         return target[prop];
       },
-      set(target, prop, value) {
+      // FIXME: Should this get a generic like get above?
+      set(target, prop, value, receiver) {
         if (prop === 'length') {
           if (!transaction && value === 0) {
             transaction = true;
-            addToTransaction(_TAG);
-            Reflect.set(target, prop, value);
-            self[MUTATE]('length 0', []);
+            self[MUTATE](target, receiver, 'length 0', [], _SIGNAL);
             transaction = false;
             return true;
           } else if (transaction) {
@@ -2755,9 +2513,23 @@ let IdentifierArray = (_class3 = class IdentifierArray {
           PrivateState.meta = value || null;
           return true;
         }
-        let index = convertToInt(prop);
+        const index = convertToInt(prop);
+
+        // we do not allow "holey" arrays and so if the index is
+        // greater than length then we will disallow setting it.
+        // however, there is a special case for "unshift" with more than
+        // one item being inserted since current items will be moved to the
+        // new indices first.
+        // we "loosely" detect this by just checking whether we are in
+        // a transaction.
         if (index === null || index > target.length) {
-          if (prop in self) {
+          if (index !== null && transaction) {
+            const identifier = recordIdentifierFor(value);
+            assert(`Cannot set index ${index} past the end of the array.`, isStableIdentifier(identifier));
+            target[index] = identifier;
+            return true;
+          } else if (isSelfProp(self, prop)) {
+            // @ts-expect-error not all properties are indeces and we can't safely cast
             self[prop] = value;
             return true;
           }
@@ -2767,12 +2539,30 @@ let IdentifierArray = (_class3 = class IdentifierArray {
           assert(`Mutating ${String(prop)} on this RecordArray is not allowed.`, options.allowMutation);
           return false;
         }
-        let original = target[index];
-        let newIdentifier = extractIdentifierFromRecord$1(value);
+        const original = target[index];
+        const newIdentifier = extractIdentifierFromRecord$1(value);
         target[index] = newIdentifier;
+        assert(`Expected a record`, isStableIdentifier(newIdentifier));
+        // We generate "transactions" whenever a setter method on the array
+        // is called and might bulk update multiple array cells. Fundamentally,
+        // all array operations decompose into individual cell replacements.
+        // e.g. a push is really a "replace cell at next index with new value"
+        // or a splice is "shift all values left/right by X and set out of new
+        // bounds cells to undefined"
+        //
+        // so, if we are in a transaction, then this is not a user generated change
+        // but one generated by a setter method. In this case we want to only apply
+        // the change to the target array and not call the MUTATE method.
+        // If there is no transaction though, then this means the user themselves has
+        // directly changed the value of a specific index and we need to thus generate
+        // a mutation for that change.
+        // e.g. "arr.push(newVal)" is handled by a "addToRelatedRecords" mutation within
+        // a transaction.
+        // while "arr[arr.length] = newVal;" is handled by this replace cell code path.
         if (!transaction) {
-          self[MUTATE]('replace cell', [index, original, newIdentifier]);
-          addToTransaction(_TAG);
+          self[MUTATE](target, receiver, 'replace cell', [index, original, newIdentifier], _SIGNAL);
+        } else {
+          target[index] = newIdentifier;
         }
         return true;
       },
@@ -2787,12 +2577,7 @@ let IdentifierArray = (_class3 = class IdentifierArray {
         return IdentifierArray.prototype;
       }
     });
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
-      const meta = Ember.meta(this);
-      meta.hasMixin = mixin => {
-        assert(`Do not call A() on EmberData RecordArrays`);
-      };
-    }
+    createArrayTags(proxy, _SIGNAL);
     this[NOTIFY] = this[NOTIFY].bind(proxy);
     return proxy;
   }
@@ -2817,8 +2602,8 @@ let IdentifierArray = (_class3 = class IdentifierArray {
       return this._updatingPromise;
     }
     this.isUpdating = true;
-    let updatingPromise = this._update();
-    updatingPromise.finally(() => {
+    const updatingPromise = this._update();
+    void updatingPromise.finally(() => {
       this._updatingPromise = null;
       if (this.isDestroying || this.isDestroyed) {
         return;
@@ -2835,6 +2620,10 @@ let IdentifierArray = (_class3 = class IdentifierArray {
    */
   _update() {
     assert(`_update cannot be used with this array`, this.modelName);
+    // @ts-expect-error typescript is unable to handle the complexity of
+    //   T = unknown, modelName = string
+    //   T extends TypedRecordInstance, modelName = TypeFromInstance<T>
+    // both being valid options to pass through here.
     return this.store.findAll(this.modelName, {
       reload: true
     });
@@ -2856,17 +2645,23 @@ let IdentifierArray = (_class3 = class IdentifierArray {
     @return {Promise<IdentifierArray>} promise
   */
   save() {
-    let promise = Promise.all(this.map(record => this.store.saveRecord(record))).then(() => this);
+    const promise = Promise.all(this.map(record => this.store.saveRecord(record))).then(() => this);
     return promise;
   }
-}, (_descriptor2 = _applyDecoratedDescriptor(_class3.prototype, "isUpdating", [tracked], {
-  configurable: true,
+}, _applyDecoratedDescriptor(_class.prototype, "length", [compat], Object.getOwnPropertyDescriptor(_class.prototype, "length"), _class.prototype), _class); // this will error if someone tries to call
+// A(identifierArray) since it is not configurable
+// which is preferable to the `meta` override we used
+// before which required importing all of Ember
+const desc = {
   enumerable: true,
-  writable: true,
-  initializer: function () {
-    return false;
+  configurable: false,
+  get: function () {
+    return this;
   }
-}), _applyDecoratedDescriptor(_class3.prototype, "length", [dependentKeyCompat], Object.getOwnPropertyDescriptor(_class3.prototype, "length"), _class3.prototype)), _class3);
+};
+compat(desc);
+Object.defineProperty(IdentifierArray.prototype, '[]', desc);
+defineSignal(IdentifierArray.prototype, 'isUpdating', false);
 class Collection extends IdentifierArray {
   constructor(options) {
     super(options);
@@ -2883,6 +2678,10 @@ class Collection extends IdentifierArray {
     // TODO save options from initial request?
     assert(`update cannot be used with this array`, this.modelName);
     assert(`update cannot be used with no query`, query);
+    // @ts-expect-error typescript is unable to handle the complexity of
+    //   T = unknown, modelName = string
+    //   T extends TypedRecordInstance, modelName = TypeFromInstance<T>
+    // both being valid options to pass through here.
     const promise = store.query(this.modelName, query, {
       _recordArray: this
     });
@@ -2898,7 +2697,8 @@ class Collection extends IdentifierArray {
 Collection.prototype.query = null;
 
 // Ensure instanceof works correctly
-//Object.setPrototypeOf(IdentifierArray.prototype, Array.prototype);
+// Object.setPrototypeOf(IdentifierArray.prototype, Array.prototype);
+
 function assertRecordPassedToHasMany(record) {
   assert(`All elements of a hasMany relationship must be instances of Model, you passed $${typeof record}`, function () {
     try {
@@ -2920,7 +2720,6 @@ function extractIdentifierFromRecord$1(record) {
 /**
   @module @ember-data/store
 */
-
 const FAKE_ARR = {};
 const SLICE_BATCH_SIZE = 1200;
 /**
@@ -2963,7 +2762,7 @@ const SLICE_BATCH_SIZE = 1200;
  */
 function fastPush(target, source) {
   let startLength = 0;
-  let newLength = source.length;
+  const newLength = source.length;
   while (newLength - startLength > SLICE_BATCH_SIZE) {
     // eslint-disable-next-line prefer-spread
     target.push.apply(target, source.slice(startLength, startLength + SLICE_BATCH_SIZE));
@@ -3020,8 +2819,8 @@ class RecordArrayManager {
   */
   liveArrayFor(type) {
     let array = this._live.get(type);
-    let identifiers = [];
-    let staged = this._staged.get(type);
+    const identifiers = [];
+    const staged = this._staged.get(type);
     if (staged) {
       staged.forEach((value, key) => {
         if (value === 'add') {
@@ -3044,7 +2843,7 @@ class RecordArrayManager {
     return array;
   }
   createArray(config) {
-    let options = {
+    const options = {
       type: config.type,
       links: config.doc?.links || null,
       meta: config.doc?.meta || null,
@@ -3055,7 +2854,7 @@ class RecordArrayManager {
       store: this.store,
       manager: this
     };
-    let array = new Collection(options);
+    const array = new Collection(options);
     this._managed.add(array);
     this._set.set(array, new Set(options.identifiers || []));
     if (config.identifiers) {
@@ -3067,7 +2866,7 @@ class RecordArrayManager {
     if (array === FAKE_ARR) {
       return;
     }
-    let tag = array[IDENTIFIER_ARRAY_TAG];
+    const tag = array[ARRAY_SIGNAL];
     if (!tag.shouldReset) {
       tag.shouldReset = true;
       addTransactionCB(array[NOTIFY]);
@@ -3079,11 +2878,11 @@ class RecordArrayManager {
     if (this.isDestroying || this.isDestroyed) {
       return;
     }
-    let liveArray = this._live.get(identifier.type);
+    const liveArray = this._live.get(identifier.type);
     const allPending = this._pending;
-    let pending = new Map();
+    const pending = new Map();
     if (includeManaged) {
-      let managed = this._identifiers.get(identifier);
+      const managed = this._identifiers.get(identifier);
       if (managed) {
         managed.forEach(arr => {
           let changes = allPending.get(arr);
@@ -3138,10 +2937,10 @@ class RecordArrayManager {
     associate(this._identifiers, array, identifiers);
   }
   identifierAdded(identifier) {
-    let changeSets = this._getPendingFor(identifier, false);
+    const changeSets = this._getPendingFor(identifier, false);
     if (changeSets) {
       changeSets.forEach((changes, array) => {
-        let existing = changes.get(identifier);
+        const existing = changes.get(identifier);
         if (existing === 'del') {
           changes.delete(identifier);
         } else {
@@ -3152,10 +2951,10 @@ class RecordArrayManager {
     }
   }
   identifierRemoved(identifier) {
-    let changeSets = this._getPendingFor(identifier, true, true);
+    const changeSets = this._getPendingFor(identifier, true, true);
     if (changeSets) {
       changeSets.forEach((changes, array) => {
-        let existing = changes.get(identifier);
+        const existing = changes.get(identifier);
         if (existing === 'add') {
           changes.delete(identifier);
         } else {
@@ -3166,7 +2965,7 @@ class RecordArrayManager {
     }
   }
   identifierChanged(identifier) {
-    let newState = this.store._instanceCache.recordIsLoaded(identifier, true);
+    const newState = this.store._instanceCache.recordIsLoaded(identifier, true);
 
     // if the change matches the most recent direct added/removed
     // state, then we can ignore it
@@ -3193,13 +2992,12 @@ class RecordArrayManager {
     this.clear(false);
     this._live.clear();
     this.isDestroyed = true;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     this.store.notifications.unsubscribe(this._subscription);
   }
 }
 function associate(ArraysCache, array, identifiers) {
   for (let i = 0; i < identifiers.length; i++) {
-    let identifier = identifiers[i];
+    const identifier = identifiers[i];
     let cache = ArraysCache.get(identifier);
     if (!cache) {
       cache = new Set();
@@ -3214,13 +3012,13 @@ function disassociate(ArraysCache, array, identifiers) {
   }
 }
 function disassociateIdentifier(ArraysCache, array, identifier) {
-  let cache = ArraysCache.get(identifier);
+  const cache = ArraysCache.get(identifier);
   if (cache) {
     cache.delete(array);
   }
 }
 function sync(array, changes, arraySet) {
-  let state = array[SOURCE];
+  const state = array[SOURCE];
   const adds = [];
   const removes = [];
   changes.forEach((value, key) => {
@@ -3234,13 +3032,13 @@ function sync(array, changes, arraySet) {
     } else {
       if (arraySet.has(key)) {
         removes.push(key);
+        arraySet.delete(key);
       }
     }
   });
   if (removes.length) {
     if (removes.length === state.length) {
       state.length = 0;
-      arraySet.clear();
       // changing the reference breaks the Proxy
       // state = array[SOURCE] = [];
     } else {
@@ -3267,6 +3065,9 @@ function sync(array, changes, arraySet) {
   }
 }
 
+/**
+ * @module @ember-data/store
+ */
 const Touching = Symbol('touching');
 const RequestPromise = Symbol('promise');
 const EMPTY_ARR = macroCondition(getOwnConfig().env.DEBUG) ? Object.freeze([]) : [];
@@ -3294,14 +3095,14 @@ class RequestStateService {
     this._done.delete(identifier);
   }
   _enqueue(promise, queryRequest) {
-    let query = queryRequest.data[0];
+    const query = queryRequest.data[0];
     if (hasRecordIdentifier(query)) {
       const identifier = query.recordIdentifier;
-      let type = query.op === 'saveRecord' ? 'mutation' : 'query';
+      const type = query.op === 'saveRecord' ? 'mutation' : 'query';
       if (!this._pending.has(identifier)) {
         this._pending.set(identifier, []);
       }
-      let request = {
+      const request = {
         state: 'pending',
         request: queryRequest,
         type
@@ -3312,7 +3113,7 @@ class RequestStateService {
       this._triggerSubscriptions(request);
       return promise.then(result => {
         this._dequeue(identifier, request);
-        let finalizedRequest = {
+        const finalizedRequest = {
           state: 'fulfilled',
           request: queryRequest,
           type,
@@ -3326,7 +3127,7 @@ class RequestStateService {
         return result;
       }, error => {
         this._dequeue(identifier, request);
-        let finalizedRequest = {
+        const finalizedRequest = {
           state: 'rejected',
           request: queryRequest,
           type,
@@ -3375,7 +3176,7 @@ class RequestStateService {
   _addDone(request) {
     request[Touching].forEach(identifier => {
       // TODO add support for multiple
-      let requestDataOp = request.request.data[0].op;
+      const requestDataOp = request.request.data[0].op;
       let requests = this._done.get(identifier);
       if (requests) {
         requests = requests.filter(req => {
@@ -3439,7 +3240,7 @@ class RequestStateService {
    * @method getPendingRequestsForRecord
    * @public
    * @param {StableRecordIdentifier} identifier
-   * @returns {RequestState[]} an array of request states for any pending requests for the given identifier
+   * @return {RequestState[]} an array of request states for any pending requests for the given identifier
    */
   getPendingRequestsForRecord(identifier) {
     return this._pending.get(identifier) || EMPTY_ARR;
@@ -3451,10 +3252,10 @@ class RequestStateService {
    * @method getLastRequestForRecord
    * @public
    * @param {StableRecordIdentifier} identifier
-   * @returns {RequestState | null} the state of the most recent request for the given identifier
+   * @return {RequestState | null} the state of the most recent request for the given identifier
    */
   getLastRequestForRecord(identifier) {
-    let requests = this._done.get(identifier);
+    const requests = this._done.get(identifier);
     if (requests) {
       return requests[requests.length - 1];
     }
@@ -3466,7 +3267,7 @@ function isNonEmptyString(str) {
 }
 function constructResource(type, id, lid) {
   if (typeof type === 'object' && type !== null) {
-    let resource = type;
+    const resource = type;
     if (isStableIdentifier(resource)) {
       return resource;
     }
@@ -3501,6 +3302,29 @@ function constructResource(type, id, lid) {
   }
 }
 
+/**
+  @module @ember-data/store
+ */
+// this import location is deprecated but breaks in 4.8 and older
+
+/**
+ * Currently only records that extend object can be created via
+ * store.createRecord. This is a limitation of the current API,
+ * but can be worked around by creating a new identifier, running
+ * the cache.clientDidCreate method, and then peeking the record
+ * for the identifier.
+ *
+ * To assign primary key to a record during creation, only `id` will
+ * work correctly for `store.createRecord`, other primary key may be
+ * handled by updating the record after creation or using the flow
+ * described above.
+ *
+ * TODO: These are limitations we want to (and can) address. If you
+ * have need of lifting these limitations, please open an issue.
+ *
+ * @typedoc
+ */
+
 /**
  * A Store coordinates interaction between your application, a [Cache](https://api.emberjs.com/ember-data/release/classes/%3CInterface%3E%20Cache),
  * and sources of data (such as your API or a local persistence layer)
@@ -3519,7 +3343,10 @@ function constructResource(type, id, lid) {
 
   @class Store
   @public
-*/ // @ts-expect-error
+*/
+
+// @ts-expect-error
+
 class Store extends EmberObject {
   /**
    * Provides access to the NotificationManager associated
@@ -3651,8 +3478,6 @@ class Store extends EmberObject {
     // private
     this._requestCache = new RequestStateService(this);
     this._instanceCache = new InstanceCache(this);
-    this._adapterCache = Object.create(null);
-    this._serializerCache = Object.create(null);
     this._documentCache = new Map();
     this.isDestroying = false;
     this.isDestroyed = false;
@@ -3710,7 +3535,7 @@ class Store extends EmberObject {
    * that have been initiated for a given identifier.
    *
    * @method getRequestStateService
-   * @returns {RequestStateService}
+   * @return {RequestStateService}
    * @public
    */
   getRequestStateService() {
@@ -3735,10 +3560,11 @@ class Store extends EmberObject {
    * inserting the response into the cache and handing
    * back a Future which resolves to a ResponseDocument
    *
-   * Resource data is always updated in the cache.
+   * ## Cache Keys
    *
-   * Only GET requests have the request result and document
-   * cached by default when a cache key is present.
+   * Only GET requests with a url or requests with an explicit
+   * cache key (`cacheOptions.key`) will have the request result
+   * and document cached.
    *
    * The cache key used is `requestConfig.cacheOptions.key`
    * if present, falling back to `requestconfig.url`.
@@ -3749,16 +3575,44 @@ class Store extends EmberObject {
    * via the `POST` method `requestConfig.cacheOptions.key`
    * MUST be supplied for the document to be cached.
    *
+   * ## Requesting Without a Cache Key
+   *
+   * Resource data within the request is always updated in the cache,
+   * regardless of whether a cache key is present for the request.
+   *
+   * ## Fulfilling From Cache
+   *
+   * When a cache-key is determined, the request may fulfill
+   * from cache provided the cache is not stale.
+   *
+   * Cache staleness is determined by the configured LifetimesService
+   * with priority given to the `cacheOptions.reload` and
+   * `cacheOptions.backgroundReload` on the request if present.
+   *
+   * If the cache data has soft expired or the request asks for a background
+   * reload, the request will fulfill from cache if possible and
+   * make a non-blocking request in the background to update the cache.
+   *
+   * If the cache data has hard expired or the request asks for a reload,
+   * the request will not fulfill from cache and will make a blocking
+   * request to update the cache.
+   *
+   * ## The Response
+   *
+   * The primary difference between `requestManager.request` and `store.request`
+   * is that `store.request` will attempt to hydrate the response content into
+   * a response Document containing RecordInstances.
+   *
    * @method request
    * @param {StoreRequestInput} requestConfig
-   * @returns {Future}
+   * @return {Future}
    * @public
    */
   request(requestConfig) {
     // we lazily set the cache handler when we issue the first request
     // because constructor doesn't allow for this to run after
     // the user has had the chance to set the prop.
-    let opts = {
+    const opts = {
       store: this,
       [EnableHydration]: true
     };
@@ -3810,7 +3664,7 @@ class Store extends EmberObject {
    * @param createRecordArgs
    * @param recordDataFor deprecated use this.cache
    * @param notificationManager deprecated use this.notifications
-   * @returns A record instance
+   * @return A record instance
    * @public
    */
 
@@ -3953,7 +3807,7 @@ class Store extends EmberObject {
   }
 
   /**
-    Returns the schema for a particular `modelName`.
+    Returns the schema for a particular resource type (modelName).
      When used with Model from @ember-data/model the return is the model class,
     but this is not guaranteed.
      If looking to query attribute or relationship information it is
@@ -3967,7 +3821,7 @@ class Store extends EmberObject {
     for example.
      @method modelFor
     @public
-    @param {String} type
+    @param {string} type
     @return {ModelSchema}
     */
   // TODO @deprecate in favor of schema APIs, requires adapter/serializer overhaul or replacement
@@ -4000,17 +3854,18 @@ class Store extends EmberObject {
     ```
      @method createRecord
     @public
-    @param {String} modelName
+    @param {String} type the name of the resource
     @param {Object} inputProperties a hash of properties to set on the
       newly created record.
     @return {Model} record
   */
-  createRecord(modelName, inputProperties) {
+
+  createRecord(type, inputProperties) {
     if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'createRecord');
     }
-    assert(`You need to pass a model name to the store's createRecord method`, modelName);
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
+    assert(`You need to pass a model name to the store's createRecord method`, type);
+    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`, typeof type === 'string');
 
     // This is wrapped in a `run.join` so that in test environments users do not need to manually wrap
     //   calls to `createRecord`. The run loop usage here is because we batch the joining and updating
@@ -4018,43 +3873,40 @@ class Store extends EmberObject {
     //
     //   to remove this, we would need to move to a new `async` API.
     let record;
-    _backburner.join(() => {
-      this._join(() => {
-        let normalizedModelName = normalizeModelName(modelName);
-        let properties = {
-          ...inputProperties
-        };
-
-        // If the passed properties do not include a primary key,
-        // give the adapter an opportunity to generate one. Typically,
-        // client-side ID generators will use something like uuid.js
-        // to avoid conflicts.
-
-        if (properties.id === null || properties.id === undefined) {
-          let adapter = this.adapterFor(modelName);
-          if (adapter && adapter.generateIdForRecord) {
-            properties.id = adapter.generateIdForRecord(this, modelName, properties);
-          } else {
-            properties.id = null;
-          }
-        }
+    this._join(() => {
+      const normalizedModelName = normalizeModelName(type);
+      const properties = {
+        ...inputProperties
+      };
 
-        // Coerce ID to a string
-        properties.id = coerceId(properties.id);
-        const resource = {
-          type: normalizedModelName,
-          id: properties.id
-        };
-        if (resource.id) {
-          const identifier = this.identifierCache.peekRecordIdentifier(resource);
-          assert(`The id ${String(properties.id)} has already been used with another '${normalizedModelName}' record.`, !identifier);
+      // If the passed properties do not include a primary key,
+      // give the adapter an opportunity to generate one. Typically,
+      // client-side ID generators will use something like uuid.js
+      // to avoid conflicts.
+      let id = null;
+      if (properties.id === null || properties.id === undefined) {
+        const adapter = this.adapterFor?.(normalizedModelName, true);
+        if (adapter && adapter.generateIdForRecord) {
+          id = properties.id = coerceId(adapter.generateIdForRecord(this, normalizedModelName, properties));
+        } else {
+          id = properties.id = null;
         }
-        const identifier = this.identifierCache.createIdentifierForNewRecord(resource);
-        const cache = this.cache;
-        const createOptions = normalizeProperties(this, identifier, properties);
-        const resultProps = cache.clientDidCreate(identifier, createOptions);
-        record = this._instanceCache.getRecord(identifier, resultProps);
-      });
+      } else {
+        id = properties.id = coerceId(properties.id);
+      }
+      const resource = {
+        type: normalizedModelName,
+        id
+      };
+      if (resource.id) {
+        const identifier = this.identifierCache.peekRecordIdentifier(resource);
+        assert(`The id ${String(properties.id)} has already been used with another '${normalizedModelName}' record.`, !identifier);
+      }
+      const identifier = this.identifierCache.createIdentifierForNewRecord(resource);
+      const cache = this.cache;
+      const createOptions = normalizeProperties(this, identifier, properties);
+      const resultProps = cache.clientDidCreate(identifier, createOptions);
+      record = this._instanceCache.getRecord(identifier, resultProps);
     });
     return record;
   }
@@ -4070,7 +3922,7 @@ class Store extends EmberObject {
     ```
      @method deleteRecord
     @public
-    @param {Model} record
+    @param {unknown} record
   */
   deleteRecord(record) {
     if (macroCondition(getOwnConfig().env.DEBUG)) {
@@ -4082,9 +3934,7 @@ class Store extends EmberObject {
     this._join(() => {
       cache.setIsDeleted(identifier, true);
       if (cache.isNew(identifier)) {
-        _backburner.join(() => {
-          this._instanceCache.unloadRecord(identifier);
-        });
+        this._instanceCache.unloadRecord(identifier);
       }
     });
   }
@@ -4166,8 +4016,7 @@ class Store extends EmberObject {
      In your adapter you can then access this id without triggering a network request via the
     snapshot:
      ```app/adapters/application.js
-    import EmberObject from '@ember/object';
-     export default class Adapter extends EmberObject {
+    export default class Adapter {
        findRecord(store, schema, id, snapshot) {
         let type = schema.modelName;
          if (type === 'comment')
@@ -4176,6 +4025,9 @@ class Store extends EmberObject {
             .then(response => response.json())
         }
       }
+       static create() {
+        return new this();
+      }
     }
     ```
      This could also be achieved by supplying the post id to the adapter via the adapterOptions
@@ -4189,9 +4041,8 @@ class Store extends EmberObject {
     }
     ```
      ```app/adapters/application.js
-    import EmberObject from '@ember/object';
-     export default class Adapter extends EmberObject {
-       findRecord(store, schema, id, snapshot) {
+    export default class Adapter {
+      findRecord(store, schema, id, snapshot) {
         let type = schema.modelName;
          if (type === 'comment')
           let postId = snapshot.adapterOptions.post;
@@ -4199,6 +4050,9 @@ class Store extends EmberObject {
             .then(response => response.json())
         }
       }
+       static create() {
+        return new this();
+      }
     }
     ```
      If you have access to the post model you can also pass the model itself to preload:
@@ -4325,9 +4179,8 @@ class Store extends EmberObject {
     }
     ```
      ```app/adapters/application.js
-    import EmberObject from '@ember/object';
-     export default class Adapter extends EmberObject {
-       findRecord(store, schema, id, snapshot) {
+    export default class Adapter {
+      findRecord(store, schema, id, snapshot) {
         let type = schema.modelName;
          if (type === 'post')
           let includes = snapshot.adapterOptions.include;
@@ -4335,6 +4188,9 @@ class Store extends EmberObject {
             .then(response => response.json())
         }
       }
+       static create() {
+        return new this();
+      }
     }
     ```
      In this case, the post's comments would then be available in your template as
@@ -4388,7 +4244,7 @@ class Store extends EmberObject {
      @since 1.13.0
     @method findRecord
     @public
-    @param {String|object} modelName - either a string representing the modelName or a ResourceIdentifier object containing both the type (a string) and the id (a string) for the record or an lid (a string) of an existing record
+    @param {String|object} type - either a string representing the name of the resource or a ResourceIdentifier object containing both the type (a string) and the id (a string) for the record or an lid (a string) of an existing record
     @param {(String|Integer|Object)} id - optional object with options for the request only if the first param is a ResourceIdentifier, else the string id of the record to be retrieved
     @param {Object} [options] - if the first param is a string this will be the optional options for the request. See examples for available options.
     @return {Promise} promise
@@ -4478,7 +4334,7 @@ class Store extends EmberObject {
       resourceIdentifier = constructResource(type, normalizedId);
     }
     assert('getReference expected to receive either a resource identifier or type and id as arguments', isMaybeIdentifier(resourceIdentifier));
-    let identifier = this.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);
+    const identifier = this.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);
     return this._instanceCache.getReference(identifier);
   }
 
@@ -4573,24 +4429,25 @@ class Store extends EmberObject {
      @since 1.13.0
     @method query
     @public
-    @param {String} modelName
-    @param {any} query an opaque query to be used by the adapter
+    @param {String} type the name of the resource
+    @param {object} query a query to be used by the adapter
     @param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter.query
     @return {Promise} promise
   */
-  query(modelName, query, options) {
+
+  query(type, query, options = {}) {
     if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'query');
     }
-    assert(`You need to pass a model name to the store's query method`, modelName);
+    assert(`You need to pass a model name to the store's query method`, type);
     assert(`You need to pass a query hash to the store's query method`, query);
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
+    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`, typeof type === 'string');
     const promise = this.request({
       op: 'query',
       data: {
-        type: normalizeModelName(modelName),
+        type: normalizeModelName(type),
         query,
-        options: options || {}
+        options: options
       },
       cacheOptions: {
         [SkipCache]: true
@@ -4848,20 +4705,21 @@ class Store extends EmberObject {
      @since 1.13.0
     @method findAll
     @public
-    @param {String} modelName
-    @param {Object} options
+    @param {string} type the name of the resource
+    @param {object} options
     @return {Promise} promise
   */
-  findAll(modelName, options = {}) {
+
+  findAll(type, options = {}) {
     if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'findAll');
     }
-    assert(`You need to pass a model name to the store's findAll method`, modelName);
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
+    assert(`You need to pass a model name to the store's findAll method`, type);
+    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`, typeof type === 'string');
     const promise = this.request({
       op: 'findAll',
       data: {
-        type: normalizeModelName(modelName),
+        type: normalizeModelName(type),
         options: options || {}
       },
       cacheOptions: {
@@ -4888,17 +4746,17 @@ class Store extends EmberObject {
      @since 1.13.0
     @method peekAll
     @public
-    @param {String} modelName
+    @param {string} type the name of the resource
     @return {RecordArray}
   */
-  peekAll(modelName) {
+
+  peekAll(type) {
     if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'peekAll');
     }
-    assert(`You need to pass a model name to the store's peekAll method`, modelName);
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
-    let type = normalizeModelName(modelName);
-    return this.recordArrayManager.liveArrayFor(type);
+    assert(`You need to pass a model name to the store's peekAll method`, type);
+    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`, typeof type === 'string');
+    return this.recordArrayManager.liveArrayFor(normalizeModelName(type));
   }
 
   /**
@@ -4910,16 +4768,17 @@ class Store extends EmberObject {
     store.unloadAll('post');
     ```
      @method unloadAll
+    @param {string} type the name of the resource
     @public
-    @param {String} modelName
   */
-  unloadAll(modelName) {
+
+  unloadAll(type) {
     if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyedStoreOnly(this, 'unloadAll');
     }
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${String(modelName)}`, !modelName || typeof modelName === 'string');
+    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${String(type)}`, !type || typeof type === 'string');
     this._join(() => {
-      if (modelName === undefined) {
+      if (type === undefined) {
         // destroy the graph before unloadAll
         // since then we avoid churning relationships
         // during unload
@@ -4927,8 +4786,7 @@ class Store extends EmberObject {
         this.recordArrayManager.clear();
         this._instanceCache.clear();
       } else {
-        let normalizedModelName = normalizeModelName(modelName);
-        this._instanceCache.clear(normalizedModelName);
+        this._instanceCache.clear(normalizeModelName(type));
       }
     });
   }
@@ -5068,10 +4926,9 @@ class Store extends EmberObject {
     if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'push');
     }
-    let pushed = this._push(data, false);
+    const pushed = this._push(data, false);
     if (Array.isArray(pushed)) {
-      let records = pushed.map(identifier => this._instanceCache.getRecord(identifier));
-      return records;
+      return pushed.map(identifier => this._instanceCache.getRecord(identifier));
     }
     if (pushed === null) {
       return null;
@@ -5093,7 +4950,7 @@ class Store extends EmberObject {
     }
     if (macroCondition(getOwnConfig().debug.LOG_PAYLOADS)) {
       try {
-        let data = JSON.parse(JSON.stringify(jsonApiDoc));
+        const data = JSON.parse(JSON.stringify(jsonApiDoc));
         // eslint-disable-next-line no-console
         console.log('EmberData | Payload - push', data);
       } catch (e) {
@@ -5101,388 +4958,682 @@ class Store extends EmberObject {
         console.log('EmberData | Payload - push', jsonApiDoc);
       }
     }
-    if (asyncFlush) {
-      this._enableAsyncFlush = true;
-    }
-    let ret;
-    this._join(() => {
-      ret = this.cache.put({
-        content: jsonApiDoc
-      });
+    if (asyncFlush) {
+      this._enableAsyncFlush = true;
+    }
+    let ret;
+    this._join(() => {
+      ret = this.cache.put({
+        content: jsonApiDoc
+      });
+    });
+    this._enableAsyncFlush = null;
+    return 'data' in ret ? ret.data : null;
+  }
+
+  /**
+   * Trigger a save for a Record.
+   *
+   * Returns a promise resolving with the same record when the save is complete.
+   *
+   * @method saveRecord
+   * @public
+   * @param {unknown} record
+   * @param options
+   * @return {Promise<record>}
+   */
+  saveRecord(record, options = {}) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
+      assertDestroyingStore(this, 'saveRecord');
+    }
+    assert(`Unable to initate save for a record in a disconnected state`, storeFor(record));
+    const identifier = recordIdentifierFor(record);
+    const cache = this.cache;
+    if (!identifier) {
+      // this commonly means we're disconnected
+      // but just in case we reject here to prevent bad things.
+      return Promise.reject(new Error(`Record Is Disconnected`));
+    }
+    // TODO we used to check if the record was destroyed here
+    assert(`Cannot initiate a save request for an unloaded record: ${identifier.lid}`, this._instanceCache.recordIsLoaded(identifier));
+    if (resourceIsFullyDeleted(this._instanceCache, identifier)) {
+      return Promise.resolve(record);
+    }
+    if (!options) {
+      options = {};
+    }
+    let operation = 'updateRecord';
+    if (cache.isNew(identifier)) {
+      operation = 'createRecord';
+    } else if (cache.isDeleted(identifier)) {
+      operation = 'deleteRecord';
+    }
+    const request = {
+      op: operation,
+      data: {
+        options,
+        record: identifier
+      },
+      records: [identifier],
+      cacheOptions: {
+        [SkipCache]: true
+      }
+    };
+
+    // we lie here on the type because legacy doesn't have enough context
+    cache.willCommit(identifier, {
+      request
+    });
+    return this.request(request).then(document => document.content);
+  }
+
+  /**
+   * Instantiation hook allowing applications or addons to configure the store
+   * to utilize a custom Cache implementation.
+   *
+   * This hook should not be called directly by consuming applications or libraries.
+   * Use `Store.cache` to access the Cache instance.
+   *
+   * @method createCache (hook)
+   * @public
+   * @param storeWrapper
+   * @return {Cache}
+   */
+
+  /**
+   * Returns the cache instance associated to this Store, instantiates the Cache
+   * if necessary via `Store.createCache`
+   *
+   * @property {Cache} cache
+   * @public
+   */
+  get cache() {
+    let {
+      cache
+    } = this._instanceCache;
+    if (!cache) {
+      cache = this._instanceCache.cache = this.createCache(this._instanceCache._storeWrapper);
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
+        cache = new CacheManager(cache);
+      }
+    }
+    return cache;
+  }
+
+  // @ts-expect-error
+  destroy() {
+    if (this.isDestroyed) {
+      // @ember/test-helpers will call destroy multiple times
+      return;
+    }
+    this.isDestroying = true;
+    this._graph?.destroy();
+    this._graph = undefined;
+    this.notifications.destroy();
+    this.recordArrayManager.destroy();
+    this.identifierCache.destroy();
+    this.unloadAll();
+    this.isDestroyed = true;
+  }
+  static create(args) {
+    return new this(args);
+  }
+}
+let assertDestroyingStore;
+let assertDestroyedStoreOnly;
+if (macroCondition(getOwnConfig().env.DEBUG)) {
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  assertDestroyingStore = function assertDestroyingStore(store, method) {
+    assert(`Attempted to call store.${method}(), but the store instance has already been destroyed.`, !(store.isDestroying || store.isDestroyed));
+  };
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  assertDestroyedStoreOnly = function assertDestroyedStoreOnly(store, method) {
+    assert(`Attempted to call store.${method}(), but the store instance has already been destroyed.`, !store.isDestroyed);
+  };
+}
+function isMaybeIdentifier(maybeIdentifier) {
+  return Boolean(maybeIdentifier !== null && typeof maybeIdentifier === 'object' && ('id' in maybeIdentifier && 'type' in maybeIdentifier && maybeIdentifier.id && maybeIdentifier.type || maybeIdentifier.lid));
+}
+function normalizeProperties(store, identifier, properties) {
+  // assert here
+  if (properties !== undefined) {
+    if ('id' in properties) {
+      assert(`expected id to be a string or null`, properties.id !== undefined);
+    }
+    assert(`You passed '${typeof properties}' as properties for record creation instead of an object.`, typeof properties === 'object' && properties !== null);
+    const {
+      type
+    } = identifier;
+
+    // convert relationship Records to RecordDatas before passing to RecordData
+    const defs = store.getSchemaDefinitionService().relationshipsDefinitionFor({
+      type
+    });
+    if (defs !== null) {
+      const keys = Object.keys(properties);
+      let relationshipValue;
+      for (let i = 0; i < keys.length; i++) {
+        const prop = keys[i];
+        const def = defs[prop];
+        if (def !== undefined) {
+          if (def.kind === 'hasMany') {
+            if (macroCondition(getOwnConfig().env.DEBUG)) {
+              assertRecordsPassedToHasMany(properties[prop]);
+            }
+            relationshipValue = extractIdentifiersFromRecords(properties[prop]);
+          } else {
+            relationshipValue = extractIdentifierFromRecord(properties[prop]);
+          }
+          properties[prop] = relationshipValue;
+        }
+      }
+    }
+  }
+  return properties;
+}
+function assertRecordsPassedToHasMany(records) {
+  assert(`You must pass an array of records to set a hasMany relationship`, Array.isArray(records));
+  assert(`All elements of a hasMany relationship must be instances of Model, you passed ${records.map(r => `${typeof r}`).join(', ')}`, function () {
+    return records.every(record => {
+      try {
+        recordIdentifierFor(record);
+        return true;
+      } catch {
+        return false;
+      }
     });
-    this._enableAsyncFlush = null;
-    return 'data' in ret ? ret.data : null;
+  }());
+}
+function extractIdentifiersFromRecords(records) {
+  return records.map(record => extractIdentifierFromRecord(record));
+}
+function extractIdentifierFromRecord(recordOrPromiseRecord) {
+  if (!recordOrPromiseRecord) {
+    return null;
   }
+  const extract = recordIdentifierFor;
+  return extract(recordOrPromiseRecord);
+}
+function urlFromLink(link) {
+  if (typeof link === 'string') return link;
+  return link.href;
+}
 
+/**
+ * A Document is a class that wraps the response content from a request to the API
+ * returned by `Cache.put` or `Cache.peek`, converting resource-identifiers into
+ * record instances.
+ *
+ * It is not directly instantiated by the user, and its properties should not
+ * be directly modified. Whether individual properties are mutable or not is
+ * determined by the record instance itself.
+ *
+ * @public
+ * @class Document
+ */
+var _store = /*#__PURE__*/_classPrivateFieldKey("store");
+var _request = /*#__PURE__*/_classPrivateFieldKey("request");
+class Document {
+  constructor(store, identifier) {
+    Object.defineProperty(this, _request, {
+      value: _request2
+    });
+    /**
+     * The links object for this document, if any
+     *
+     * e.g.
+     *
+     * ```
+     * {
+     *   self: '/articles?page[number]=3',
+     * }
+     * ```
+     *
+     * @property links
+     * @type {object|undefined} - a links object
+     * @public
+     */
+    /**
+     * The primary data for this document, if any.
+     *
+     * If this document has no primary data (e.g. because it is an error document)
+     * this property will be `undefined`.
+     *
+     * For collections this will be an array of record instances,
+     * for single resource requests it will be a single record instance or null.
+     *
+     * @property data
+     * @public
+     * @type {object|Array<object>|null|undefined} - a data object
+     */
+    /**
+     * The errors returned by the API for this request, if any
+     *
+     * @property errors
+     * @public
+     * @type {object|undefined} - an errors object
+     */
+    /**
+     * The meta object for this document, if any
+     *
+     * @property meta
+     * @public
+     * @type {object|undefined} - a meta object
+     */
+    /**
+     * The identifier associated with this document, if any
+     *
+     * @property identifier
+     * @public
+     * @type {StableDocumentIdentifier|null}
+     */
+    Object.defineProperty(this, _store, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldBase(this, _store)[_store] = store;
+    this.identifier = identifier;
+  }
   /**
-    Push some raw data into the store.
-     This method can be used both to push in brand new
-    records, as well as to update existing records. You
-    can push in more than one type of object at once.
-    All objects should be in the format expected by the
-    serializer.
-     ```app/serializers/application.js
-    import RESTSerializer from '@ember-data/serializer/rest';
-     export default class ApplicationSerializer extends RESTSerializer;
-    ```
-     ```js
-    let pushData = {
-      posts: [
-        { id: 1, postTitle: "Great post", commentIds: [2] }
-      ],
-      comments: [
-        { id: 2, commentBody: "Insightful comment" }
-      ]
-    }
-     store.pushPayload(pushData);
-    ```
-     By default, the data will be deserialized using a default
-    serializer (the application serializer if it exists).
-     Alternatively, `pushPayload` will accept a model type which
-    will determine which serializer will process the payload.
-     ```app/serializers/application.js
-    import RESTSerializer from '@ember-data/serializer/rest';
-      export default class ApplicationSerializer extends RESTSerializer;
-    ```
-     ```app/serializers/post.js
-    import JSONSerializer from '@ember-data/serializer/json';
-     export default JSONSerializer;
-    ```
-     ```js
-    store.pushPayload(pushData); // Will use the application serializer
-    store.pushPayload('post', pushData); // Will use the post serializer
-    ```
-     @method pushPayload
-    @public
-    @param {String} modelName Optionally, a model type used to determine which serializer will be used
-    @param {Object} inputPayload
-  */
-  // TODO @runspired @deprecate pushPayload in favor of looking up the serializer
-  pushPayload(modelName, inputPayload) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
-      assertDestroyingStore(this, 'pushPayload');
-    }
-    const payload = inputPayload || modelName;
-    const normalizedModelName = inputPayload ? normalizeModelName(modelName) : 'application';
-    const serializer = this.serializerFor(normalizedModelName);
-    assert(`You cannot use 'store.pushPayload(<type>, <payload>)' unless the serializer for '${normalizedModelName}' defines 'pushPayload'`, serializer && typeof serializer.pushPayload === 'function');
-    serializer.pushPayload(this, payload);
+   * Fetches the related link for this document, returning a promise that resolves
+   * with the document when the request completes. If no related link is present,
+   * will fallback to the self link if present
+   *
+   * @method fetch
+   * @public
+   * @param {object} options
+   * @return Promise<Document>
+   */
+  fetch(options = {}) {
+    assert(`No self or related link`, this.links?.related || this.links?.self);
+    options.cacheOptions = options.cacheOptions || {};
+    options.cacheOptions.key = this.identifier?.lid;
+    return _classPrivateFieldBase(this, _request)[_request](this.links.related ? 'related' : 'self', options);
   }
 
   /**
-   * Trigger a save for a Record.
+   * Fetches the next link for this document, returning a promise that resolves
+   * with the new document when the request completes, or null  if there is no
+   * next link.
    *
-   * @method saveRecord
+   * @method next
    * @public
-   * @param {RecordInstance} record
-   * @param options
-   * @returns {Promise<RecordInstance>}
+   * @param {object} options
+   * @return Promise<Document | null>
    */
-  saveRecord(record, options = {}) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
-      assertDestroyingStore(this, 'saveRecord');
-    }
-    assert(`Unable to initate save for a record in a disconnected state`, storeFor(record));
-    let identifier = recordIdentifierFor(record);
-    const cache = this.cache;
-    if (!identifier) {
-      // this commonly means we're disconnected
-      // but just in case we reject here to prevent bad things.
-      return Promise.reject(`Record Is Disconnected`);
-    }
-    // TODO we used to check if the record was destroyed here
-    assert(`Cannot initiate a save request for an unloaded record: ${identifier.lid}`, this._instanceCache.recordIsLoaded(identifier));
-    if (resourceIsFullyDeleted(this._instanceCache, identifier)) {
-      return Promise.resolve(record);
-    }
-    if (!options) {
-      options = {};
-    }
-    let operation = 'updateRecord';
-    if (cache.isNew(identifier)) {
-      operation = 'createRecord';
-    } else if (cache.isDeleted(identifier)) {
-      operation = 'deleteRecord';
-    }
-    const request = {
-      op: operation,
-      data: {
-        options,
-        record: identifier
-      },
-      cacheOptions: {
-        [SkipCache]: true
-      }
-    };
+  next(options = {}) {
+    return _classPrivateFieldBase(this, _request)[_request]('next', options);
+  }
 
-    // we lie here on the type because legacy doesn't have enough context
-    cache.willCommit(identifier, {
-      request
-    });
-    return this.request(request).then(document => document.content);
+  /**
+   * Fetches the prev link for this document, returning a promise that resolves
+   * with the new document when the request completes, or null if there is no
+   * prev link.
+   *
+   * @method prev
+   * @public
+   * @param {object} options
+   * @return Promise<Document | null>
+   */
+  prev(options = {}) {
+    return _classPrivateFieldBase(this, _request)[_request]('prev', options);
   }
 
   /**
-   * Instantiation hook allowing applications or addons to configure the store
-   * to utilize a custom Cache implementation.
+   * Fetches the first link for this document, returning a promise that resolves
+   * with the new document when the request completes, or null if there is no
+   * first link.
    *
-   * This hook should not be called directly by consuming applications or libraries.
-   * Use `Store.cache` to access the Cache instance.
+   * @method first
+   * @public
+   * @param {object} options
+   * @return Promise<Document | null>
+   */
+  first(options = {}) {
+    return _classPrivateFieldBase(this, _request)[_request]('first', options);
+  }
+
+  /**
+   * Fetches the last link for this document, returning a promise that resolves
+   * with the new document when the request completes, or null if there is no
+   * last link.
    *
-   * @method createCache (hook)
+   * @method last
    * @public
-   * @param storeWrapper
-   * @returns {Cache}
+   * @param {object} options
+   * @return Promise<Document | null>
    */
+  last(options = {}) {
+    return _classPrivateFieldBase(this, _request)[_request]('last', options);
+  }
 
   /**
-   * Returns the cache instance associated to this Store, instantiates the Cache
-   * if necessary via `Store.createCache`
+   * Implemented for `JSON.stringify` support.
    *
-   * @property {Cache} cache
+   * Returns the JSON representation of the document wrapper.
+   *
+   * This is a shallow serialization, it does not deeply serialize
+   * the document's contents, leaving that to the individual record
+   * instances to determine how to do, if at all.
+   *
+   * @method toJSON
    * @public
+   * @return
    */
-  get cache() {
-    let {
-      cache
-    } = this._instanceCache;
-    if (!cache) {
-      cache = this._instanceCache.cache = this.createCache(this._instanceCache._storeWrapper);
-      if (macroCondition(getOwnConfig().env.DEBUG)) {
-        cache = new CacheManager(cache);
-      }
+  toJSON() {
+    const data = {};
+    data.identifier = this.identifier;
+    if (this.data !== undefined) {
+      data.data = this.data;
     }
-    return cache;
+    if (this.links !== undefined) {
+      data.links = this.links;
+    }
+    if (this.errors !== undefined) {
+      data.errors = this.errors;
+    }
+    if (this.meta !== undefined) {
+      data.meta = this.meta;
+    }
+    return data;
+  }
+}
+async function _request2(link, options) {
+  const href = this.links?.[link];
+  if (!href) {
+    return null;
   }
+  options.method = options.method || 'GET';
+  const response = await _classPrivateFieldBase(this, _store)[_store].request(Object.assign(options, {
+    url: urlFromLink(href)
+  }));
+  return response.content;
+}
+defineSignal(Document.prototype, 'data');
+defineSignal(Document.prototype, 'links');
+defineSignal(Document.prototype, 'errors');
+defineSignal(Document.prototype, 'meta');
 
-  /**
-    `normalize` converts a json payload into the normalized form that
-    [push](../methods/push?anchor=push) expects.
-     Example
-     ```js
-    socket.on('message', function(message) {
-      let modelName = message.model;
-      let data = message.data;
-      store.push(store.normalize(modelName, data));
-    });
-    ```
-     @method normalize
-    @public
-    @param {String} modelName The name of the model type for this payload
-    @param {Object} payload
-    @return {Object} The normalized payload
-  */
-  // TODO @runspired @deprecate users should call normalize on the associated serializer directly
-  normalize(modelName, payload) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
-      assertDestroyingStore(this, 'normalize');
+/**
+ * @module @ember-data/store
+ */
+
+/**
+ * A service which an application may provide to the store via
+ * the store's `lifetimes` property to configure the behavior
+ * of the CacheHandler.
+ *
+ * The default behavior for request lifetimes is to never expire
+ * unless manually refreshed via `cacheOptions.reload` or `cacheOptions.backgroundReload`.
+ *
+ * Implementing this service allows you to programatically define
+ * when a request should be considered expired.
+ *
+ * @class <Interface> LifetimesService
+ * @public
+ */
+
+const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);
+function isErrorDocument(document) {
+  return 'errors' in document;
+}
+function maybeUpdateUiObjects(store, request, options, document, isFromCache) {
+  const {
+    identifier
+  } = options;
+  if (isErrorDocument(document)) {
+    if (!identifier && !options.shouldHydrate) {
+      return document;
+    }
+    let doc;
+    if (identifier) {
+      doc = store._documentCache.get(identifier);
+    }
+    if (!doc) {
+      doc = new Document(store, identifier);
+      copyDocumentProperties(doc, document);
+      if (identifier) {
+        store._documentCache.set(identifier, doc);
+      }
+    } else if (!isFromCache) {
+      doc.data = undefined;
+      copyDocumentProperties(doc, document);
+    }
+    return options.shouldHydrate ? doc : document;
+  }
+  if (Array.isArray(document.data)) {
+    const {
+      recordArrayManager
+    } = store;
+    if (!identifier) {
+      if (!options.shouldHydrate) {
+        return document;
+      }
+      const data = recordArrayManager.createArray({
+        type: request.url,
+        identifiers: document.data,
+        doc: document,
+        query: request
+      });
+      const doc = new Document(store, null);
+      doc.data = data;
+      doc.meta = document.meta;
+      doc.links = document.links;
+      return doc;
     }
-    assert(`You need to pass a model name to the store's normalize method`, modelName);
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${typeof modelName}`, typeof modelName === 'string');
-    const normalizedModelName = normalizeModelName(modelName);
-    const serializer = this.serializerFor(normalizedModelName);
-    const schema = this.modelFor(normalizedModelName);
-    assert(`You must define a normalize method in your serializer in order to call store.normalize`, typeof serializer?.normalize === 'function');
-    return serializer.normalize(schema, payload);
-  }
-
-  /**
-    Returns an instance of the adapter for a given type. For
-    example, `adapterFor('person')` will return an instance of
-    the adapter located at `app/adapters/person.js`
-     If no `person` adapter is found, this method will look
-    for an `application` adapter (the default adapter for
-    your entire application).
-     @method adapterFor
-    @public
-    @param {String} modelName
-    @return Adapter
-  */
-  adapterFor(modelName) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
-      assertDestroyingStore(this, 'adapterFor');
+    let managed = recordArrayManager._keyedArrays.get(identifier.lid);
+    if (!managed) {
+      managed = recordArrayManager.createArray({
+        type: identifier.lid,
+        identifiers: document.data,
+        doc: document
+      });
+      recordArrayManager._keyedArrays.set(identifier.lid, managed);
+      const doc = new Document(store, identifier);
+      doc.data = managed;
+      doc.meta = document.meta;
+      doc.links = document.links;
+      store._documentCache.set(identifier, doc);
+      return options.shouldHydrate ? doc : document;
+    } else {
+      const doc = store._documentCache.get(identifier);
+      if (!isFromCache) {
+        recordArrayManager.populateManagedArray(managed, document.data, document);
+        doc.data = managed;
+        doc.meta = document.meta;
+        doc.links = document.links;
+      }
+      return options.shouldHydrate ? doc : document;
     }
-    assert(`You need to pass a model name to the store's adapterFor method`, modelName);
-    assert(`Passing classes to store.adapterFor has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
-    let normalizedModelName = normalizeModelName(modelName);
-    let {
-      _adapterCache
-    } = this;
-    let adapter = _adapterCache[normalizedModelName];
-    if (adapter) {
-      return adapter;
+  } else {
+    if (!identifier && !options.shouldHydrate) {
+      return document;
     }
-    const owner = getOwner(this);
-
-    // name specific adapter
-    adapter = owner.lookup(`adapter:${normalizedModelName}`);
-    if (adapter !== undefined) {
-      _adapterCache[normalizedModelName] = adapter;
-      return adapter;
+    const data = document.data ? store.peekRecord(document.data) : null;
+    let doc;
+    if (identifier) {
+      doc = store._documentCache.get(identifier);
     }
-
-    // no adapter found for the specific name, fallback and check for application adapter
-    adapter = _adapterCache.application || owner.lookup('adapter:application');
-    if (adapter !== undefined) {
-      _adapterCache[normalizedModelName] = adapter;
-      _adapterCache.application = adapter;
-      return adapter;
+    if (!doc) {
+      doc = new Document(store, identifier);
+      doc.data = data;
+      copyDocumentProperties(doc, document);
+      if (identifier) {
+        store._documentCache.set(identifier, doc);
+      }
+    } else if (!isFromCache) {
+      doc.data = data;
+      copyDocumentProperties(doc, document);
     }
-    assert(`No adapter was found for '${modelName}' and no 'application' adapter was found as a fallback.`);
+    return options.shouldHydrate ? doc : document;
   }
-
-  /**
-    Returns an instance of the serializer for a given type. For
-    example, `serializerFor('person')` will return an instance of
-    `App.PersonSerializer`.
-     If no `App.PersonSerializer` is found, this method will look
-    for an `App.ApplicationSerializer` (the default serializer for
-    your entire application).
-     If a serializer cannot be found on the adapter, it will fall back
-    to an instance of `JSONSerializer`.
-     @method serializerFor
-    @public
-    @param {String} modelName the record to serialize
-    @return {Serializer}
-  */
-  serializerFor(modelName) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
-      assertDestroyingStore(this, 'serializerFor');
-    }
-    assert(`You need to pass a model name to the store's serializerFor method`, modelName);
-    assert(`Passing classes to store.serializerFor has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
-    let normalizedModelName = normalizeModelName(modelName);
-    let {
-      _serializerCache
-    } = this;
-    let serializer = _serializerCache[normalizedModelName];
-    if (serializer) {
-      return serializer;
-    }
-
-    // by name
-    const owner = getOwner(this);
-    serializer = owner.lookup(`serializer:${normalizedModelName}`);
-    if (serializer !== undefined) {
-      _serializerCache[normalizedModelName] = serializer;
-      return serializer;
+}
+function calcShouldFetch(store, request, hasCachedValue, identifier) {
+  const {
+    cacheOptions
+  } = request;
+  return request.op && MUTATION_OPS.has(request.op) || cacheOptions?.reload || !hasCachedValue || (store.lifetimes && identifier ? store.lifetimes.isHardExpired(identifier, store) : false);
+}
+function calcShouldBackgroundFetch(store, request, willFetch, identifier) {
+  const {
+    cacheOptions
+  } = request;
+  return !willFetch && (cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier, store) : false));
+}
+function isMutation(request) {
+  return Boolean(request.op && MUTATION_OPS.has(request.op));
+}
+function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBackgroundFetch) {
+  const {
+    store
+  } = context.request;
+  const shouldHydrate = context.request[EnableHydration] || false;
+  let isMut = false;
+  if (isMutation(context.request)) {
+    isMut = true;
+    // TODO should we handle multiple records in request.records by iteratively calling willCommit for each
+    const record = context.request.data?.record || context.request.records?.[0];
+    assert(`Expected to receive a list of records included in the ${context.request.op} request`, record);
+    store.cache.willCommit(record, context);
+  }
+  if (store.lifetimes?.willRequest) {
+    store.lifetimes.willRequest(context.request, identifier, store);
+  }
+  const promise = next(context.request).then(document => {
+    store.requestManager._pending.delete(context.id);
+    store._enableAsyncFlush = true;
+    let response;
+    store._join(() => {
+      if (isMutation(context.request)) {
+        const record = context.request.data?.record || context.request.records?.[0];
+        response = store.cache.didCommit(record, document);
+      } else {
+        response = store.cache.put(document);
+      }
+      response = maybeUpdateUiObjects(store, context.request, {
+        shouldHydrate,
+        shouldFetch,
+        shouldBackgroundFetch,
+        identifier
+      }, response, false);
+    });
+    store._enableAsyncFlush = null;
+    if (store.lifetimes?.didRequest) {
+      store.lifetimes.didRequest(context.request, document.response, identifier, store);
     }
-
-    // no serializer found for the specific model, fallback and check for application serializer
-    serializer = _serializerCache.application || owner.lookup('serializer:application');
-    if (serializer !== undefined) {
-      _serializerCache[normalizedModelName] = serializer;
-      _serializerCache.application = serializer;
-      return serializer;
+    if (shouldFetch) {
+      return response;
+    } else if (shouldBackgroundFetch) {
+      store.notifications._flush();
     }
-    return null;
-  }
-
-  // @ts-expect-error
-  destroy() {
-    if (this.isDestroyed) {
-      // @ember/test-helpers will call destroy multiple times
-      return;
+  }, error => {
+    store.requestManager._pending.delete(context.id);
+    if (context.request.signal?.aborted) {
+      throw error;
     }
-    this.isDestroying = true;
-    // enqueue destruction of any adapters/serializers we have created
-    for (let adapterName in this._adapterCache) {
-      let adapter = this._adapterCache[adapterName];
-      if (typeof adapter.destroy === 'function') {
-        adapter.destroy();
+    store.requestManager._pending.delete(context.id);
+    store._enableAsyncFlush = true;
+    let response;
+    store._join(() => {
+      if (isMutation(context.request)) {
+        // TODO similar to didCommit we should spec this to be similar to cache.put for handling full response
+        // currently we let the response remain undefiend.
+        const errors = error && error.content && typeof error.content === 'object' && 'errors' in error.content && Array.isArray(error.content.errors) ? error.content.errors : undefined;
+        const record = context.request.data?.record || context.request.records?.[0];
+        store.cache.commitWasRejected(record, errors);
+        // re-throw the original error to preserve `errors` property.
+        throw error;
+      } else {
+        response = store.cache.put(error);
+        response = maybeUpdateUiObjects(store, context.request, {
+          shouldHydrate,
+          shouldFetch,
+          shouldBackgroundFetch,
+          identifier
+        }, response, false);
       }
+    });
+    store._enableAsyncFlush = null;
+    if (identifier && store.lifetimes?.didRequest) {
+      store.lifetimes.didRequest(context.request, error.response, identifier, store);
     }
-    for (let serializerName in this._serializerCache) {
-      let serializer = this._serializerCache[serializerName];
-      if (typeof serializer.destroy === 'function') {
-        serializer.destroy();
-      }
+    if (!shouldBackgroundFetch) {
+      const newError = cloneError(error);
+      newError.content = response;
+      throw newError;
+    } else {
+      store.notifications._flush();
     }
-    this._graph?.destroy();
-    this._graph = undefined;
-    this.notifications.destroy();
-    this.recordArrayManager.destroy();
-    this.identifierCache.destroy();
-    this.unloadAll();
-    this.isDestroyed = true;
-  }
-  static create(args) {
-    return new this(args);
+  });
+  if (!isMut) {
+    return promise;
   }
+  assert(`Expected a mutation`, isMutation(context.request));
+
+  // for mutations we need to enqueue the promise with the requestStateService
+  // TODO should we enque a request per record in records?
+  const record = context.request.data?.record || context.request.records?.[0];
+  return store._requestCache._enqueue(promise, {
+    data: [{
+      op: 'saveRecord',
+      recordIdentifier: record,
+      options: undefined
+    }]
+  });
 }
-let assertDestroyingStore;
-let assertDestroyedStoreOnly;
-if (macroCondition(getOwnConfig().env.DEBUG)) {
-  // eslint-disable-next-line @typescript-eslint/no-shadow
-  assertDestroyingStore = function assertDestroyingStore(store, method) {
-    assert(`Attempted to call store.${method}(), but the store instance has already been destroyed.`, !(store.isDestroying || store.isDestroyed));
-  };
-  // eslint-disable-next-line @typescript-eslint/no-shadow
-  assertDestroyedStoreOnly = function assertDestroyedStoreOnly(store, method) {
-    assert(`Attempted to call store.${method}(), but the store instance has already been destroyed.`, !store.isDestroyed);
-  };
-}
-function isMaybeIdentifier(maybeIdentifier) {
-  return Boolean(maybeIdentifier !== null && typeof maybeIdentifier === 'object' && ('id' in maybeIdentifier && 'type' in maybeIdentifier && maybeIdentifier.id && maybeIdentifier.type || maybeIdentifier.lid));
+function cloneError(error) {
+  const cloned = new Error(error.message);
+  cloned.stack = error.stack;
+  cloned.error = error.error;
+  return cloned;
 }
-function normalizeProperties(store, identifier, properties) {
-  // assert here
-  if (properties !== undefined) {
-    if ('id' in properties) {
-      assert(`expected id to be a string or null`, properties.id !== undefined);
+const CacheHandler = {
+  request(context, next) {
+    // if we have no cache or no cache-key skip cache handling
+    if (!context.request.store || context.request.cacheOptions?.[SkipCache]) {
+      return next(context.request);
     }
-    assert(`You passed '${typeof properties}' as properties for record creation instead of an object.`, typeof properties === 'object' && properties !== null);
     const {
-      type
-    } = identifier;
+      store
+    } = context.request;
+    const identifier = store.identifierCache.getOrCreateDocumentIdentifier(context.request);
+    const peeked = identifier ? store.cache.peekRequest(identifier) : null;
 
-    // convert relationship Records to RecordDatas before passing to RecordData
-    let defs = store.getSchemaDefinitionService().relationshipsDefinitionFor({
-      type
-    });
-    if (defs !== null) {
-      let keys = Object.keys(properties);
-      let relationshipValue;
-      for (let i = 0; i < keys.length; i++) {
-        let prop = keys[i];
-        let def = defs[prop];
-        if (def !== undefined) {
-          if (def.kind === 'hasMany') {
-            if (macroCondition(getOwnConfig().env.DEBUG)) {
-              assertRecordsPassedToHasMany(properties[prop]);
-            }
-            relationshipValue = extractIdentifiersFromRecords(properties[prop]);
-          } else {
-            relationshipValue = extractIdentifierFromRecord(properties[prop]);
-          }
-          properties[prop] = relationshipValue;
-        }
-      }
+    // determine if we should skip cache
+    if (calcShouldFetch(store, context.request, !!peeked, identifier)) {
+      return fetchContentAndHydrate(next, context, identifier, true, false);
+    }
+
+    // if we have not skipped cache, determine if we should update behind the scenes
+    if (calcShouldBackgroundFetch(store, context.request, false, identifier)) {
+      const promise = fetchContentAndHydrate(next, context, identifier, false, true);
+      store.requestManager._pending.set(context.id, promise);
+    }
+    const shouldHydrate = context.request[EnableHydration] || false;
+    if ('error' in peeked) {
+      const content = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
+        shouldHydrate,
+        identifier
+      }, peeked.content, true) : peeked.content;
+      const newError = cloneError(peeked);
+      newError.content = content;
+      throw newError;
     }
+    return Promise.resolve(shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
+      shouldHydrate,
+      identifier
+    }, peeked.content, true) : peeked.content);
   }
-  return properties;
-}
-function assertRecordsPassedToHasMany(records) {
-  assert(`You must pass an array of records to set a hasMany relationship`, Array.isArray(records));
-  assert(`All elements of a hasMany relationship must be instances of Model, you passed ${records.map(r => `${typeof r}`).join(', ')}`, function () {
-    return records.every(record => {
-      try {
-        recordIdentifierFor(record);
-        return true;
-      } catch {
-        return false;
-      }
-    });
-  }());
-}
-function extractIdentifiersFromRecords(records) {
-  return records.map(record => extractIdentifierFromRecord(record));
-}
-function extractIdentifierFromRecord(recordOrPromiseRecord) {
-  if (!recordOrPromiseRecord) {
-    return null;
+};
+function copyDocumentProperties(target, source) {
+  if ('links' in source) {
+    target.links = source.links;
+  }
+  if ('meta' in source) {
+    target.meta = source.meta;
+  }
+  if ('errors' in source) {
+    target.errors = source.errors;
   }
-  const extract = recordIdentifierFor;
-  return extract(recordOrPromiseRecord);
 }
-export { CacheHandler as C, IdentifierArray as I, MUTATE as M, RecordArrayManager as R, Store as S, _clearCaches as _, setIdentifierGenerationMethod as a, setIdentifierUpdateMethod as b, setIdentifierForgetMethod as c, setIdentifierResetMethod as d, coerceId as e, Collection as f, SOURCE as g, IDENTIFIER_ARRAY_TAG as h, isStableIdentifier as i, fastPush as j, removeRecordDataFor as k, setRecordIdentifier as l, StoreMap as m, notifyArray as n, setCacheFor as o, peekCache as p, recordIdentifierFor as r, storeFor as s };
+export { ARRAY_SIGNAL as A, CacheHandler as C, IdentifierArray as I, MUTATE as M, RecordArrayManager as R, Store as S, _clearCaches as _, setIdentifierGenerationMethod as a, setIdentifierUpdateMethod as b, setIdentifierForgetMethod as c, setIdentifierResetMethod as d, coerceId as e, Collection as f, SOURCE as g, fastPush as h, isStableIdentifier as i, removeRecordDataFor as j, setRecordIdentifier as k, StoreMap as l, setCacheFor as m, notifyArray as n, normalizeModelName as o, peekCache as p, recordIdentifierFor as r, storeFor as s };