@ember-data/store 4.12.0-beta.3 → 4.12.0-beta.5

package/addon/{index-bebb407b.js → index-123f3e7e.js}

@@ -1,10 +1,8 @@
-import { macroCondition, getOwnConfig, isDevelopingApp, dependencySatisfies, importSync } from '@embroider/macros';
+import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
 import { assert, warn, deprecate } from '@ember/debug';
 import { dasherize } from '@ember/string';
 import { getOwner, setOwner } from '@ember/application';
 import { _backburner } from '@ember/runloop';
-import { registerWaiter, unregisterWaiter } from '@ember/test';
-import RSVP, { resolve, Promise as Promise$1, reject } from 'rsvp';
 import { tracked } from '@glimmer/tracking';
 import { subscribe, addToTransaction, addTransactionCB } from '@ember-data/tracking/-private';
 import { tagForProperty } from '@ember/-internals/metal';
@@ -38,6 +36,26 @@ function normalizeModelName$1(modelName) {
   return dasherize(modelName);
 }
 
+/*
+ * Returns the Cache instance associated with a given
+ * Model or Identifier
+ */
+
+const CacheForIdentifierCache = new Map();
+function setCacheFor(identifier, cache) {
+  assert(`Illegal set of identifier`, !CacheForIdentifierCache.has(identifier) || CacheForIdentifierCache.get(identifier) === cache);
+  CacheForIdentifierCache.set(identifier, cache);
+}
+function removeRecordDataFor(identifier) {
+  CacheForIdentifierCache.delete(identifier);
+}
+function peekCache(instance) {
+  if (CacheForIdentifierCache.has(instance)) {
+    return CacheForIdentifierCache.get(instance);
+  }
+  return null;
+}
+
 /**
   @module @ember-data/store
 */
@@ -139,7 +157,7 @@ function uuidv4() {
   assert('crypto.randomUUID needs to be avaliable. Some browsers incorrectly disallow it in insecure contexts. You maybe want to enable the polyfill: https://github.com/emberjs/data#randomuuid-polyfill', _crypto.randomUUID);
   return _crypto.randomUUID();
 }
-function freeze$1(obj) {
+function freeze(obj) {
   if (typeof Object.freeze === 'function') {
     return Object.freeze(obj);
   }
@@ -179,7 +197,7 @@ function defaultGenerationMethod(data, bucket) {
 }
 function defaultEmptyCallback(...args) {}
 let DEBUG_MAP;
-if (macroCondition(isDevelopingApp())) {
+if (macroCondition(getOwnConfig().env.DEBUG)) {
   DEBUG_MAP = new WeakMap();
 }
 
@@ -233,7 +251,7 @@ class IdentifierCache {
   _getRecordIdentifier(resource, shouldGenerate = false) {
     // short circuit if we're already the stable version
     if (isStableIdentifier(resource)) {
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         // TODO should we instead just treat this case as a new generation skipping the short circuit?
         if (!this._cache.lids.has(resource.lid) || this._cache.lids.get(resource.lid) !== resource) {
           throw new Error(`The supplied identifier ${resource} does not belong to this store instance`);
@@ -307,7 +325,7 @@ class IdentifierCache {
           identifier = makeStableRecordIdentifier(id, type, newLid, 'record', false);
 
           // populate our unique table
-          if (macroCondition(isDevelopingApp())) {
+          if (macroCondition(getOwnConfig().env.DEBUG)) {
             // realistically if you hit this it means you changed `type` :/
             // TODO consider how to handle type change assertions more gracefully
             if (this._cache.lids.has(identifier.lid)) {
@@ -386,6 +404,7 @@ class IdentifierCache {
     @returns {StableRecordIdentifier}
     @public
   */
+
   getOrCreateRecordIdentifier(resource) {
     return this._getRecordIdentifier(resource, true);
   }
@@ -407,7 +426,7 @@ class IdentifierCache {
     let keyOptions = getTypeIndex(this._cache.types, data.type);
 
     // populate our unique table
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       if (this._cache.lids.has(identifier.lid)) {
         throw new Error(`The lid generated for the new record is not unique as it matches an existing identifier`);
       }
@@ -421,7 +440,7 @@ class IdentifierCache {
     }
     if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
       // eslint-disable-next-line no-console
-      console.log(`Identifiers: createded identifier ${String(identifier)} for newly generated resource`, data);
+      console.log(`Identifiers: created identifier ${String(identifier)} for newly generated resource`, data);
     }
     return identifier;
   }
@@ -561,7 +580,7 @@ function makeStableRecordIdentifier(id, type, lid, bucket, clientOriginated = fa
     type
   };
   IDENTIFIERS.add(recordIdentifier);
-  if (macroCondition(isDevelopingApp())) {
+  if (macroCondition(getOwnConfig().env.DEBUG)) {
     // we enforce immutability in dev
     //  but preserve our ability to do controlled updates to the reference
     let wrapper = {
@@ -599,13 +618,13 @@ function makeStableRecordIdentifier(id, type, lid, bucket, clientOriginated = fa
     wrapper[DEBUG_IDENTIFIER_BUCKET] = bucket;
     IDENTIFIERS.add(wrapper);
     DEBUG_MAP.set(wrapper, recordIdentifier);
-    wrapper = freeze$1(wrapper);
+    wrapper = freeze(wrapper);
     return wrapper;
   }
   return recordIdentifier;
 }
 function performRecordIdentifierUpdate(identifier, data, updateFn) {
-  if (macroCondition(isDevelopingApp())) {
+  if (macroCondition(getOwnConfig().env.DEBUG)) {
     let {
       lid
     } = data;
@@ -708,6 +727,14 @@ function _applyDecoratedDescriptor(target, property, decorators, descriptor, con
   return desc;
 }
 let tokenId = 0;
+const CacheOperations = new Set(['added', 'removed', 'state', 'updated']);
+function isCacheOperationValue(value) {
+  return CacheOperations.has(value);
+}
+function runLoopIsFlushing() {
+  //@ts-expect-error
+  return !!_backburner.currentInstance && _backburner._autorun !== true;
+}
 const Cache = new Map();
 const Tokens = new Map();
 // TODO this isn't importable anyway, remove and use a map on the manager?
@@ -725,6 +752,7 @@ function unsubscribe(token) {
     map?.delete(token);
   }
 }
+
 /*
   Currently only support a single callback per identifier
 */
@@ -743,6 +771,8 @@ class NotificationManager {
   constructor(store) {
     this.store = store;
     this.isDestroyed = false;
+    this._buffered = new Map();
+    this._hasFlush = false;
   }
 
   /**
@@ -763,13 +793,13 @@ class NotificationManager {
    * @returns {UnsubscribeToken} an opaque token to be used with unsubscribe
    */
   subscribe(identifier, callback) {
-    assert(`Expected to receive a stable Identifier to subscribe to`, isStableIdentifier(identifier));
+    assert(`Expected to receive a stable Identifier to subscribe to`, identifier === 'resource' || identifier === 'document' || isStableIdentifier(identifier));
     let map = Cache.get(identifier);
     if (!map) {
       map = new Map();
       Cache.set(identifier, map);
     }
-    let unsubToken = macroCondition(isDevelopingApp()) ? {
+    let unsubToken = macroCondition(getOwnConfig().env.DEBUG) ? {
       _tokenRef: tokenId++
     } : {};
     map.set(unsubToken, callback);
@@ -790,27 +820,93 @@ class NotificationManager {
     }
   }
 
-  // deactivated type signature overloads because pass-through was failing to match any. Bring back if possible.
-  // notify(identifier: StableRecordIdentifier, value: 'attributes' | 'relationships', key?: string): boolean;
-  // notify(identifier: StableRecordIdentifier, value: 'errors' | 'meta' | 'identity' | 'state'): boolean;
+  /**
+   * Custom Caches and Application Code should not call this method directly.
+   *
+   * @method notify
+   * @param identifier
+   * @param value
+   * @param key
+   * @return {Boolean} whether a notification was delivered to any subscribers
+   * @private
+   */
+
   notify(identifier, value, key) {
-    assert(`Notify does not accept a key argument for the namespace '${value}'. Received key '${key}'.`, !key || value === 'attributes' || value === 'relationships');
+    assert(`Notify does not accept a key argument for the namespace '${value}'. Received key '${key || ''}'.`, !key || value === 'attributes' || value === 'relationships');
     if (!isStableIdentifier(identifier)) {
       if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
         // eslint-disable-next-line no-console
-        console.log(`Notifying: Expected to receive a stable Identifier to notify '${value}' '${key}' with, but ${String(identifier)} is not in the cache`, identifier);
+        console.log(`Notifying: Expected to receive a stable Identifier to notify '${value}' '${key || ''}' with, but ${String(identifier)} is not in the cache`, identifier);
       }
       return false;
     }
     if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
       // eslint-disable-next-line no-console
-      console.log(`Notifying: ${String(identifier)}\t${value}\t${key}`);
+      console.log(`Buffering Notify: ${String(identifier)}\t${value}\t${key || ''}`);
+    }
+    const hasSubscribers = Boolean(Cache.get(identifier)?.size);
+    if (isCacheOperationValue(value) || hasSubscribers) {
+      let buffer = this._buffered.get(identifier);
+      if (!buffer) {
+        buffer = [];
+        this._buffered.set(identifier, buffer);
+      }
+      buffer.push([value, key]);
+      void this._scheduleNotify();
+    }
+    return hasSubscribers;
+  }
+  _onNextFlush(cb) {
+    this._onFlushCB = cb;
+  }
+  _scheduleNotify() {
+    const asyncFlush = this.store._enableAsyncFlush;
+    if (this._hasFlush) {
+      if (asyncFlush !== false && !runLoopIsFlushing()) {
+        return;
+      }
+    }
+    if (asyncFlush && !runLoopIsFlushing()) {
+      this._hasFlush = true;
+      return;
+    }
+    this._flush();
+  }
+  _flush() {
+    if (this._buffered.size) {
+      this._buffered.forEach((states, identifier) => {
+        states.forEach(args => {
+          // @ts-expect-error
+          this._flushNotification(identifier, args[0], args[1]);
+        });
+      });
+      this._buffered = new Map();
+    }
+    this._hasFlush = false;
+    this._onFlushCB?.();
+    this._onFlushCB = undefined;
+  }
+  _flushNotification(identifier, value, key) {
+    if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
+      // eslint-disable-next-line no-console
+      console.log(`Notifying: ${String(identifier)}\t${value}\t${key || ''}`);
+    }
+
+    // TODO for documents this will need to switch based on Identifier kind
+    if (isCacheOperationValue(value)) {
+      let callbackMap = Cache.get('resource');
+      if (callbackMap) {
+        callbackMap.forEach(cb => {
+          cb(identifier, value);
+        });
+      }
     }
     let callbackMap = Cache.get(identifier);
     if (!callbackMap || !callbackMap.size) {
       return false;
     }
     callbackMap.forEach(cb => {
+      // @ts-expect-error overload doesn't narrow within body
       cb(identifier, value, key);
     });
     return true;
@@ -942,7 +1038,7 @@ let RecordReference = (_class$2 = class RecordReference {
   */
   push(objectOrPromise) {
     // TODO @deprecate pushing unresolved payloads
-    return resolve(objectOrPromise).then(data => {
+    return Promise.resolve(objectOrPromise).then(data => {
       return this.store.push(data);
     });
   }
@@ -1025,14 +1121,49 @@ var id = 0;
 function _classPrivateFieldKey(name) {
   return "__private_" + id++ + "_" + name;
 }
-var _store = /*#__PURE__*/_classPrivateFieldKey("store");
-var _recordData = /*#__PURE__*/_classPrivateFieldKey("recordData");
-var _identifier = /*#__PURE__*/_classPrivateFieldKey("identifier");
-var _isDeprecated = /*#__PURE__*/_classPrivateFieldKey("isDeprecated");
+function legacyCachePut(store, doc) {
+  const jsonApiDoc = doc.content;
+  let ret;
+  store._join(() => {
+    let included = jsonApiDoc.included;
+    let i, length;
+    if (included) {
+      for (i = 0, length = included.length; i < length; i++) {
+        store._instanceCache.loadData(included[i]);
+      }
+    }
+    if (Array.isArray(jsonApiDoc.data)) {
+      length = jsonApiDoc.data.length;
+      let identifiers = [];
+      for (i = 0; i < length; i++) {
+        identifiers.push(store._instanceCache.loadData(jsonApiDoc.data[i]));
+      }
+      ret = {
+        data: identifiers
+      };
+      return;
+    }
+    if (jsonApiDoc.data === null) {
+      ret = {
+        data: null
+      };
+      return;
+    }
+    assert(`Expected an object in the 'data' property in a call to 'push', but was ${typeof jsonApiDoc.data}`, typeof jsonApiDoc.data === 'object');
+    ret = {
+      data: store._instanceCache.loadData(jsonApiDoc.data)
+    };
+    return;
+  });
+  return ret;
+}
+
 /**
- * The CacheManager wraps a Cache
- * enforcing that only the public API surface area
- * is exposed.
+ * The CacheManager wraps a Cache enforcing that only
+ * the public API surface area is exposed.
+ *
+ * Hence, it is the value of `Store.cache`, wrapping
+ * the cache instance returned by `Store.createCache`.
  *
  * This class is the the return value of both the
  * `recordDataFor` function supplied to the store
@@ -1069,11 +1200,15 @@ var _isDeprecated = /*#__PURE__*/_classPrivateFieldKey("isDeprecated");
  * @class CacheManager
  * @public
  */
+var _store = /*#__PURE__*/_classPrivateFieldKey("store");
+var _cache = /*#__PURE__*/_classPrivateFieldKey("cache");
+var _identifier = /*#__PURE__*/_classPrivateFieldKey("identifier");
+var _isDeprecated = /*#__PURE__*/_classPrivateFieldKey("isDeprecated");
 class NonSingletonCacheManager {
   get managedVersion() {
-    return _classPrivateFieldBase(this, _recordData)[_recordData].version || '1';
+    return _classPrivateFieldBase(this, _cache)[_cache].version || '1';
   }
-  constructor(store, _recordData2, identifier) {
+  constructor(store, _cache2, identifier) {
     Object.defineProperty(this, _isDeprecated, {
       value: _isDeprecated2
     });
@@ -1082,7 +1217,7 @@ class NonSingletonCacheManager {
       writable: true,
       value: void 0
     });
-    Object.defineProperty(this, _recordData, {
+    Object.defineProperty(this, _cache, {
       writable: true,
       value: void 0
     });
@@ -1091,9 +1226,9 @@ class NonSingletonCacheManager {
       value: void 0
     });
     _classPrivateFieldBase(this, _store)[_store] = store;
-    _classPrivateFieldBase(this, _recordData)[_recordData] = _recordData2;
+    _classPrivateFieldBase(this, _cache)[_cache] = _cache2;
     _classPrivateFieldBase(this, _identifier)[_identifier] = identifier;
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](_recordData2)) {
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](_cache2)) {
       deprecate(`This RecordData uses the deprecated V1 RecordData Spec. Upgrade to V2 to maintain compatibility.`, false, {
         id: 'ember-data:deprecate-v1-cache',
         until: '5.0',
@@ -1105,44 +1240,42 @@ class NonSingletonCacheManager {
       });
     }
   }
-  // Cache
-  // =====
+  // Cache Management
+  // ================
 
   /**
-   * Retrieve the identifier for this v1 recordData
+   * Cache the response to a request
    *
-   * DEPRECATED Caches should not be assumed to be 1:1 with resources
+   * Unlike `store.push` which has UPSERT
+   * semantics, `put` has `replace` semantics similar to
+   * the `http` method `PUT`
    *
-   * @method getResourceIdentifier
-   * @public
-   * @deprecated
-   */
-  getResourceIdentifier() {
-    return _classPrivateFieldBase(this, _identifier)[_identifier];
-  }
-
-  /**
-   * Push resource data from a remote source into the cache for this identifier
+   * the individually cacheabl
+   * e resource data it may contain
+   * should upsert, but the document data surrounding it should
+   * fully replace any existing information
    *
-   * @method pushData
+   * Note that in order to support inserting arbitrary data
+   * to the cache that did not originate from a request `put`
+   * should expect to sometimes encounter a document with only
+   * a `content` member and therefor must not assume the existence
+   * of `request` and `response` on the document.
+   *
+   * @method put
+   * @param {StructuredDocument} doc
+   * @returns {ResourceDocument}
    * @public
-   * @param identifier
-   * @param data
-   * @param hasRecord
-   * @returns {void | string[]} if `hasRecord` is true then calculated key changes should be returned
    */
-  pushData(identifier, data, hasRecord) {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    // called by something V1
-    if (!isStableIdentifier(identifier)) {
-      data = identifier;
-      hasRecord = data;
-      identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
-    }
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
-      return recordData.pushData(data, hasRecord);
+  put(doc) {
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      if (doc instanceof Error) {
+        // in legacy we don't know how to handle this
+        throw doc;
+      }
+      return legacyCachePut(_classPrivateFieldBase(this, _store)[_store], doc);
     }
-    return recordData.pushData(identifier, data, hasRecord);
+    return cache.put(doc);
   }
 
   /**
@@ -1151,48 +1284,49 @@ class NonSingletonCacheManager {
    * Note: currently the only valid operation is a MergeOperation
    * which occurs when a collision of identifiers is detected.
    *
-   * @method sync
+   * @method patch
    * @public
    * @param op the operation to perform
    * @returns {void}
    */
-  sync(op) {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
+  patch(op) {
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
       return;
     }
-    recordData.sync(op);
+    cache.patch(op);
   }
 
   /**
    * Update resource data with a local mutation. Currently supports operations
    * on relationships only.
    *
-   * @method update
+   * @method mutate
    * @public
-   * @param operation
+   * @param mutation
    */
-  // isCollection is only needed for interop with v1 cache
-  update(operation, isResource) {
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](_classPrivateFieldBase(this, _recordData)[_recordData])) {
-      const cache = _classPrivateFieldBase(this, _store)[_store]._instanceCache;
-      switch (operation.op) {
+  // isResource is only needed for interop with v1 cache
+  mutate(mutation, isResource) {
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      const instanceCache = _classPrivateFieldBase(this, _store)[_store]._instanceCache;
+      switch (mutation.op) {
         case 'addToRelatedRecords':
-          _classPrivateFieldBase(this, _recordData)[_recordData].addToHasMany(operation.field, operation.value.map(i => cache.getRecordData(i)), operation.index);
+          cache.addToHasMany(mutation.field, mutation.value.map(i => instanceCache.getResourceCache(i)), mutation.index);
           return;
         case 'removeFromRelatedRecords':
-          _classPrivateFieldBase(this, _recordData)[_recordData].removeFromHasMany(operation.field, operation.value.map(i => cache.getRecordData(i)));
+          cache.removeFromHasMany(mutation.field, mutation.value.map(i => instanceCache.getResourceCache(i)));
           return;
         case 'replaceRelatedRecords':
-          _classPrivateFieldBase(this, _recordData)[_recordData].setDirtyHasMany(operation.field, operation.value.map(i => cache.getRecordData(i)));
+          cache.setDirtyHasMany(mutation.field, mutation.value.map(i => instanceCache.getResourceCache(i)));
           return;
         case 'replaceRelatedRecord':
           if (isResource) {
-            _classPrivateFieldBase(this, _recordData)[_recordData].setDirtyBelongsTo(operation.field, operation.value ? cache.getRecordData(operation.value) : null);
+            cache.setDirtyBelongsTo(mutation.field, mutation.value ? instanceCache.getResourceCache(mutation.value) : null);
             return;
           }
-          _classPrivateFieldBase(this, _recordData)[_recordData].removeFromHasMany(operation.field, [cache.getRecordData(operation.prior)]);
-          _classPrivateFieldBase(this, _recordData)[_recordData].addToHasMany(operation.field, [cache.getRecordData(operation.value)], operation.index);
+          cache.removeFromHasMany(mutation.field, [instanceCache.getResourceCache(mutation.prior)]);
+          cache.addToHasMany(mutation.field, [instanceCache.getResourceCache(mutation.value)], mutation.index);
           return;
         case 'sortRelatedRecords':
           return;
@@ -1200,10 +1334,255 @@ class NonSingletonCacheManager {
           return;
       }
     } else {
-      _classPrivateFieldBase(this, _recordData)[_recordData].update(operation);
+      cache.mutate(mutation);
+    }
+  }
+
+  /**
+   * Peek resource data from the Cache.
+   *
+   * In development, if the return value
+   * is JSON the return value
+   * will be deep-cloned and deep-frozen
+   * to prevent mutation thereby enforcing cache
+   * Immutability.
+   *
+   * This form of peek is useful for implementations
+   * that want to feed raw-data from cache to the UI
+   * or which want to interact with a blob of data
+   * directly from the presentation cache.
+   *
+   * 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
+   * and Cache to present data on a per-field basis.
+   *
+   * This generally takes the place of `getAttr` as
+   * an API and may even take the place of `getRelationship`
+   * depending on implementation specifics, though this
+   * latter usage is less recommended due to the advantages
+   * of the Graph handling necessary entanglements and
+   * notifications for relational data.
+   *
+   * @method peek
+   * @public
+   * @param {StableRecordIdentifier | StableDocumentIdentifier} identifier
+   * @returns {ResourceDocument | ResourceBlob | null} the known resource data
+   */
+
+  peek(identifier) {
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      throw new Error(`Expected cache to implement peek`);
+    }
+    return cache.peek(identifier);
+  }
+
+  /**
+   * Peek the Cache for the existing request data associated with
+   * a cacheable request
+   *
+   * @method peekRequest
+   * @param {StableDocumentIdentifier}
+   * @returns {StableDocumentIdentifier | null}
+   * @public
+   */
+  peekRequest(identifier) {
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      throw new Error(`Expected cache to implement peekRequest`);
+    }
+    return cache.peekRequest(identifier);
+  }
+
+  /**
+   * Push resource data from a remote source into the cache for this identifier
+   *
+   * @method upsert
+   * @public
+   * @param identifier
+   * @param data
+   * @param hasRecord
+   * @returns {void | string[]} if `hasRecord` is true then calculated key changes should be returned
+   */
+  upsert(identifier, data, hasRecord) {
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    // called by something V1
+    if (!isStableIdentifier(identifier)) {
+      data = identifier;
+      hasRecord = data;
+      identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
+    }
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      return cache.pushData(data, hasRecord);
+    }
+    return cache.upsert(identifier, data, hasRecord);
+  }
+
+  // Cache Forking Support
+  // =====================
+
+  /**
+   * Create a fork of the cache from the current state.
+   *
+   * Applications should typically not call this method themselves,
+   * preferring instead to fork at the Store level, which will
+   * utilize this method to fork the cache.
+   *
+   * @method fork
+   * @public
+   * @returns Promise<Cache>
+   */
+  fork() {
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      throw new Error(`Expected cache to implement fork`);
+    }
+    return cache.fork();
+  }
+
+  /**
+   * Merge a fork back into a parent Cache.
+   *
+   * Applications should typically not call this method themselves,
+   * preferring instead to merge at the Store level, which will
+   * utilize this method to merge the caches.
+   *
+   * @method merge
+   * @param {Cache} cache
+   * @public
+   * @returns Promise<void>
+   */
+  merge(updates) {
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      throw new Error(`Expected cache to implement merge`);
+    }
+    return cache.merge(updates);
+  }
+
+  /**
+   * Generate the list of changes applied to all
+   * record in the store.
+   *
+   * Each individual resource or document that has
+   * been mutated should be described as an individual
+   * `Change` entry in the returned array.
+   *
+   * A `Change` is described by an object containing up to
+   * three properties: (1) the `identifier` of the entity that
+   * changed; (2) the `op` code of that change being one of
+   * `upsert` or `remove`, and if the op is `upsert` a `patch`
+   * containing the data to merge into the cache for the given
+   * entity.
+   *
+   * This `patch` is opaque to the Store but should be understood
+   * by the Cache and may expect to be utilized by an Adapter
+   * when generating data during a `save` operation.
+   *
+   * It is generally recommended that the `patch` contain only
+   * the updated state, ignoring fields that are unchanged
+   *
+   * ```ts
+   * interface Change {
+   *  identifier: StableRecordIdentifier | StableDocumentIdentifier;
+   *  op: 'upsert' | 'remove';
+   *  patch?: unknown;
+   * }
+   * ```
+   *
+   * @method diff
+   * @public
+   */
+  diff() {
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      throw new Error(`Expected cache to implement diff`);
+    }
+    return cache.diff();
+  }
+
+  // SSR Support
+  // ===========
+
+  /**
+   * Serialize the entire contents of the Cache into a Stream
+   * which may be fed back into a new instance of the same Cache
+   * via `cache.hydrate`.
+   *
+   * @method dump
+   * @returns {Promise<ReadableStream>}
+   * @public
+   */
+  dump() {
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      throw new Error(`Expected cache to implement dump`);
+    }
+    return cache.dump();
+  }
+
+  /**
+   * hydrate a Cache from a Stream with content previously serialized
+   * from another instance of the same Cache, resolving when hydration
+   * is complete.
+   *
+   * This method should expect to be called both in the context of restoring
+   * the Cache during application rehydration after SSR **AND** at unknown
+   * times during the lifetime of an already booted application when it is
+   * desired to bulk-load additional information into the cache. This latter
+   * behavior supports optimizing pre/fetching of data for route transitions
+   * via data-only SSR modes.
+   *
+   * @method hydrate
+   * @param {ReadableStream} stream
+   * @returns {Promise<void>}
+   * @public
+   */
+  hydrate(stream) {
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      throw new Error(`Expected cache to implement hydrate`);
     }
+    return cache.hydrate(stream);
+  }
+
+  // Cache
+  // =====
+
+  /**
+   * Retrieve the identifier for this v1 cache
+   *
+   * DEPRECATED Caches should not be assumed to be 1:1 with resources
+   *
+   * @method getResourceIdentifier
+   * @public
+   * @deprecated
+   */
+  getResourceIdentifier() {
+    return _classPrivateFieldBase(this, _identifier)[_identifier];
+  }
+
+  /**
+   * Push resource data from a remote source into the cache for this identifier
+   *
+   * DEPRECATED Use upsert. Caches should not be assumed to be 1:1 with resources
+   *
+   * @method pushData
+   * @param data
+   * @param hasRecord
+   * @returns {void | string[]} if `hasRecord` is true then calculated key changes should be returned
+   * @public
+   * @deprecated
+   */
+  pushData(data, hasRecord) {
+    return this.upsert(_classPrivateFieldBase(this, _identifier)[_identifier], data, hasRecord);
   }
 
+  // Resource Support
+  // ================
+
   /**
    * [LIFECYLCE] Signal to the cache that a new record has been instantiated on the client
    *
@@ -1221,15 +1600,15 @@ class NonSingletonCacheManager {
       options = identifier;
       identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
     }
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
 
     // TODO deprecate return value
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
-      recordData.clientDidCreate();
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      cache.clientDidCreate();
       // if a V2 is calling a V1 we need to call both methods
-      return recordData._initRecordCreateOptions(options);
+      return cache._initRecordCreateOptions(options);
     } else {
-      return recordData.clientDidCreate(identifier, options);
+      return cache.clientDidCreate(identifier, options);
     }
   }
 
@@ -1245,9 +1624,9 @@ class NonSingletonCacheManager {
    * @param options
    */
   _initRecordCreateOptions(options) {
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
-      return recordData._initRecordCreateOptions(options);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      return cache._initRecordCreateOptions(options);
     }
   }
 
@@ -1260,7 +1639,7 @@ class NonSingletonCacheManager {
    * @param identifier
    */
   willCommit(identifier) {
-    _classPrivateFieldBase(this, _recordData)[_recordData].willCommit(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+    _classPrivateFieldBase(this, _cache)[_cache].willCommit(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 
   /**
@@ -1278,8 +1657,8 @@ class NonSingletonCacheManager {
       data = identifier;
       identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
     }
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.didCommit(data) : recordData.didCommit(identifier, data);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.didCommit(data) : cache.didCommit(identifier, data);
   }
 
   /**
@@ -1292,7 +1671,7 @@ class NonSingletonCacheManager {
    * @param errors
    */
   commitWasRejected(identifier, errors) {
-    _classPrivateFieldBase(this, _recordData)[_recordData].commitWasRejected(identifier || _classPrivateFieldBase(this, _identifier)[_identifier], errors);
+    _classPrivateFieldBase(this, _cache)[_cache].commitWasRejected(identifier || _classPrivateFieldBase(this, _identifier)[_identifier], errors);
   }
 
   /**
@@ -1304,16 +1683,16 @@ class NonSingletonCacheManager {
    * @param identifier
    */
   unloadRecord(identifier) {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
-      recordData.unloadRecord();
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      cache.unloadRecord();
     } else {
-      recordData.unloadRecord(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+      cache.unloadRecord(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
     }
   }
 
-  // Attrs
-  // =====
+  // Granular Resource Data APIs
+  // ===========================
 
   /**
    * Retrieve the data for an attribute from the cache
@@ -1330,8 +1709,8 @@ class NonSingletonCacheManager {
       propertyName = identifier;
       identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
     }
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.getAttr(propertyName) : recordData.getAttr(identifier, propertyName);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.getAttr(propertyName) : cache.getAttr(identifier, propertyName);
   }
 
   /**
@@ -1344,8 +1723,8 @@ class NonSingletonCacheManager {
    * @param value
    */
   setAttr(identifier, propertyName, value) {
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.setDirtyAttribute(propertyName, value) : recordData.setAttr(identifier, propertyName, value);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.setDirtyAttribute(propertyName, value) : cache.setAttr(identifier, propertyName, value);
   }
 
   /**
@@ -1361,8 +1740,8 @@ class NonSingletonCacheManager {
    * @param value
    */
   setDirtyAttribute(propertyName, value) {
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.setDirtyAttribute(propertyName, value) : recordData.setAttr(_classPrivateFieldBase(this, _identifier)[_identifier], propertyName, value);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.setDirtyAttribute(propertyName, value) : cache.setAttr(_classPrivateFieldBase(this, _identifier)[_identifier], propertyName, value);
   }
 
   /**
@@ -1377,11 +1756,11 @@ class NonSingletonCacheManager {
    * @returns
    */
   changedAttributes() {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
-      return recordData.changedAttributes();
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      return cache.changedAttributes();
     }
-    return recordData.changedAttrs(_classPrivateFieldBase(this, _identifier)[_identifier]);
+    return cache.changedAttrs(_classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 
   /**
@@ -1394,11 +1773,11 @@ class NonSingletonCacheManager {
    * @returns
    */
   changedAttrs(identifier) {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
-      return recordData.changedAttributes();
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      return cache.changedAttributes();
     }
-    return recordData.changedAttrs(identifier);
+    return cache.changedAttrs(identifier);
   }
 
   /**
@@ -1412,8 +1791,8 @@ class NonSingletonCacheManager {
    * @returns {boolean}
    */
   hasChangedAttributes() {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.hasChangedAttributes() : recordData.hasChangedAttrs(_classPrivateFieldBase(this, _identifier)[_identifier]);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.hasChangedAttributes() : cache.hasChangedAttrs(_classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 
   /**
@@ -1425,8 +1804,8 @@ class NonSingletonCacheManager {
    * @returns {boolean}
    */
   hasChangedAttrs(identifier) {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.hasChangedAttributes() : recordData.hasChangedAttrs(identifier);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.hasChangedAttributes() : cache.hasChangedAttrs(identifier);
   }
 
   /**
@@ -1440,8 +1819,8 @@ class NonSingletonCacheManager {
    * @returns
    */
   rollbackAttributes() {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.rollbackAttributes() : recordData.rollbackAttrs(_classPrivateFieldBase(this, _identifier)[_identifier]);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.rollbackAttributes() : cache.rollbackAttrs(_classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 
   /**
@@ -1453,8 +1832,8 @@ class NonSingletonCacheManager {
    * @returns the names of attributes that were restored
    */
   rollbackAttrs(identifier) {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.rollbackAttributes() : recordData.rollbackAttrs(identifier);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.rollbackAttributes() : cache.rollbackAttrs(identifier);
   }
 
   // Relationships
@@ -1476,12 +1855,12 @@ class NonSingletonCacheManager {
    * @returns resource relationship object
    */
   getRelationship(identifier, propertyName, isCollection = false) {
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
       let isBelongsTo = !isCollection;
-      return isBelongsTo ? recordData.getBelongsTo(propertyName) : recordData.getHasMany(propertyName);
+      return isBelongsTo ? cache.getBelongsTo(propertyName) : cache.getHasMany(propertyName);
     }
-    return recordData.getRelationship(identifier, propertyName);
+    return cache.getRelationship(identifier, propertyName);
   }
 
   /**
@@ -1496,12 +1875,12 @@ class NonSingletonCacheManager {
    * @returns single resource relationship object
    */
   getBelongsTo(propertyName) {
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
-      return recordData.getBelongsTo(propertyName);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      return cache.getBelongsTo(propertyName);
     } else {
       let identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
-      return recordData.getRelationship(identifier, propertyName);
+      return cache.getRelationship(identifier, propertyName);
     }
   }
 
@@ -1517,12 +1896,12 @@ class NonSingletonCacheManager {
    * @returns single resource relationship object
    */
   getHasMany(propertyName) {
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData)) {
-      return recordData.getHasMany(propertyName);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    if (_classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache)) {
+      return cache.getHasMany(propertyName);
     } else {
       let identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
-      return recordData.getRelationship(identifier, propertyName);
+      return cache.getRelationship(identifier, propertyName);
     }
   }
 
@@ -1538,8 +1917,8 @@ class NonSingletonCacheManager {
    * @param value
    */
   setDirtyBelongsTo(propertyName, value) {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.setDirtyBelongsTo(propertyName, value) : recordData.update({
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.setDirtyBelongsTo(propertyName, value) : cache.mutate({
       op: 'replaceRelatedRecord',
       record: _classPrivateFieldBase(this, _identifier)[_identifier],
       field: propertyName,
@@ -1563,8 +1942,8 @@ class NonSingletonCacheManager {
    */
   addToHasMany(propertyName, value, idx) {
     const identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.addToHasMany(propertyName, value, idx) : recordData.update({
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.addToHasMany(propertyName, value, idx) : cache.mutate({
       op: 'addToRelatedRecords',
       field: propertyName,
       record: identifier,
@@ -1585,8 +1964,8 @@ class NonSingletonCacheManager {
    */
   removeFromHasMany(propertyName, value) {
     const identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.removeFromHasMany(propertyName, value) : recordData.update({
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.removeFromHasMany(propertyName, value) : cache.mutate({
       op: 'removeFromRelatedRecords',
       record: identifier,
       field: propertyName,
@@ -1606,8 +1985,8 @@ class NonSingletonCacheManager {
    * @param value
    */
   setDirtyHasMany(propertyName, value) {
-    let recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.setDirtyHasMany(propertyName, value) : recordData.update({
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.setDirtyHasMany(propertyName, value) : cache.mutate({
       op: 'replaceRelatedRecords',
       record: _classPrivateFieldBase(this, _identifier)[_identifier],
       field: propertyName,
@@ -1615,8 +1994,8 @@ class NonSingletonCacheManager {
     });
   }
 
-  // State
-  // =============
+  // Resource State
+  // ===============
 
   /**
    * Update the cache state for the given resource to be marked as locally deleted,
@@ -1632,8 +2011,8 @@ class NonSingletonCacheManager {
       isDeleted = identifier;
       identifier = _classPrivateFieldBase(this, _identifier)[_identifier];
     }
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.setIsDeleted(isDeleted) : recordData.setIsDeleted(identifier, isDeleted);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.setIsDeleted(isDeleted) : cache.setIsDeleted(identifier, isDeleted);
   }
 
   /**
@@ -1645,7 +2024,7 @@ class NonSingletonCacheManager {
    * @returns
    */
   getErrors(identifier) {
-    return _classPrivateFieldBase(this, _recordData)[_recordData].getErrors(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+    return _classPrivateFieldBase(this, _cache)[_cache].getErrors(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 
   /**
@@ -1657,8 +2036,8 @@ class NonSingletonCacheManager {
    * @returns {boolean}
    */
   isEmpty(identifier) {
-    const recordData = _classPrivateFieldBase(this, _recordData)[_recordData];
-    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](recordData) ? recordData.isEmpty?.(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]) || false : recordData.isEmpty(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+    const cache = _classPrivateFieldBase(this, _cache)[_cache];
+    return _classPrivateFieldBase(this, _isDeprecated)[_isDeprecated](cache) ? cache.isEmpty?.(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]) || false : cache.isEmpty(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 
   /**
@@ -1671,7 +2050,7 @@ class NonSingletonCacheManager {
    * @returns {boolean}
    */
   isNew(identifier) {
-    return _classPrivateFieldBase(this, _recordData)[_recordData].isNew(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+    return _classPrivateFieldBase(this, _cache)[_cache].isNew(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 
   /**
@@ -1684,7 +2063,7 @@ class NonSingletonCacheManager {
    * @returns {boolean}
    */
   isDeleted(identifier) {
-    return _classPrivateFieldBase(this, _recordData)[_recordData].isDeleted(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+    return _classPrivateFieldBase(this, _cache)[_cache].isDeleted(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 
   /**
@@ -1697,106 +2076,120 @@ class NonSingletonCacheManager {
    * @returns {boolean}
    */
   isDeletionCommitted(identifier) {
-    return _classPrivateFieldBase(this, _recordData)[_recordData].isDeletionCommitted(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
+    return _classPrivateFieldBase(this, _cache)[_cache].isDeletionCommitted(identifier || _classPrivateFieldBase(this, _identifier)[_identifier]);
   }
 }
-function _isDeprecated2(recordData) {
-  let version = recordData.version || '1';
+function _isDeprecated2(cache) {
+  let version = cache.version || '1';
   return version !== this.version;
 }
-var _recordDatas = /*#__PURE__*/_classPrivateFieldKey("recordDatas");
-var _recordData3 = /*#__PURE__*/_classPrivateFieldKey("recordData");
+var _cache3 = /*#__PURE__*/_classPrivateFieldKey("cache");
 class SingletonCacheManager {
-  constructor() {
-    Object.defineProperty(this, _recordData3, {
-      value: _recordData4
-    });
+  constructor(cache) {
     this.version = '2';
-    Object.defineProperty(this, _recordDatas, {
+    Object.defineProperty(this, _cache3, {
       writable: true,
       value: void 0
     });
-    _classPrivateFieldBase(this, _recordDatas)[_recordDatas] = new Map();
+    _classPrivateFieldBase(this, _cache3)[_cache3] = cache;
   }
-  _addRecordData(identifier, recordData) {
-    _classPrivateFieldBase(this, _recordDatas)[_recordDatas].set(identifier, recordData);
+  put(doc) {
+    return _classPrivateFieldBase(this, _cache3)[_cache3].put(doc);
   }
+  peek(identifier) {
+    return _classPrivateFieldBase(this, _cache3)[_cache3].peek(identifier);
+  }
+  peekRequest(identifier) {
+    return _classPrivateFieldBase(this, _cache3)[_cache3].peekRequest(identifier);
+  }
+  fork() {
+    return _classPrivateFieldBase(this, _cache3)[_cache3].fork();
+  }
+  merge(cache) {
+    return _classPrivateFieldBase(this, _cache3)[_cache3].merge(cache);
+  }
+  diff() {
+    return _classPrivateFieldBase(this, _cache3)[_cache3].diff();
+  }
+  dump() {
+    return _classPrivateFieldBase(this, _cache3)[_cache3].dump();
+  }
+  hydrate(stream) {
+    return _classPrivateFieldBase(this, _cache3)[_cache3].hydrate(stream);
+  }
+
   // Cache
   // =====
 
-  pushData(identifier, data, hasRecord) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).pushData(identifier, data, hasRecord);
+  upsert(identifier, data, hasRecord) {
+    return _classPrivateFieldBase(this, _cache3)[_cache3].upsert(identifier, data, hasRecord);
   }
-  sync(op) {
-    _classPrivateFieldBase(this, _recordData3)[_recordData3](op.record).sync(op);
+  patch(op) {
+    _classPrivateFieldBase(this, _cache3)[_cache3].patch(op);
   }
   clientDidCreate(identifier, options) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).clientDidCreate(identifier, options);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].clientDidCreate(identifier, options);
   }
   willCommit(identifier) {
-    _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).willCommit(identifier);
+    _classPrivateFieldBase(this, _cache3)[_cache3].willCommit(identifier);
   }
   didCommit(identifier, data) {
-    _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).didCommit(identifier, data);
+    _classPrivateFieldBase(this, _cache3)[_cache3].didCommit(identifier, data);
   }
   commitWasRejected(identifier, errors) {
-    _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).commitWasRejected(identifier, errors);
+    _classPrivateFieldBase(this, _cache3)[_cache3].commitWasRejected(identifier, errors);
   }
   unloadRecord(identifier) {
-    _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).unloadRecord(identifier);
+    _classPrivateFieldBase(this, _cache3)[_cache3].unloadRecord(identifier);
   }
 
   // Attrs
   // =====
 
   getAttr(identifier, propertyName) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).getAttr(identifier, propertyName);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].getAttr(identifier, propertyName);
   }
   setAttr(identifier, propertyName, value) {
-    _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).setAttr(identifier, propertyName, value);
+    _classPrivateFieldBase(this, _cache3)[_cache3].setAttr(identifier, propertyName, value);
   }
   changedAttrs(identifier) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).changedAttrs(identifier);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].changedAttrs(identifier);
   }
   hasChangedAttrs(identifier) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).hasChangedAttrs(identifier);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].hasChangedAttrs(identifier);
   }
   rollbackAttrs(identifier) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).rollbackAttrs(identifier);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].rollbackAttrs(identifier);
   }
   getRelationship(identifier, propertyName) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).getRelationship(identifier, propertyName);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].getRelationship(identifier, propertyName);
   }
-  update(operation) {
-    _classPrivateFieldBase(this, _recordData3)[_recordData3](operation.record).update(operation);
+  mutate(mutation) {
+    _classPrivateFieldBase(this, _cache3)[_cache3].mutate(mutation);
   }
 
   // State
   // =============
 
   setIsDeleted(identifier, isDeleted) {
-    _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).setIsDeleted(identifier, isDeleted);
+    _classPrivateFieldBase(this, _cache3)[_cache3].setIsDeleted(identifier, isDeleted);
   }
   getErrors(identifier) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).getErrors(identifier);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].getErrors(identifier);
   }
   isEmpty(identifier) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).isEmpty(identifier);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].isEmpty(identifier);
   }
   isNew(identifier) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).isNew(identifier);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].isNew(identifier);
   }
   isDeleted(identifier) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).isDeleted(identifier);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].isDeleted(identifier);
   }
   isDeletionCommitted(identifier) {
-    return _classPrivateFieldBase(this, _recordData3)[_recordData3](identifier).isDeletionCommitted(identifier);
+    return _classPrivateFieldBase(this, _cache3)[_cache3].isDeletionCommitted(identifier);
   }
 }
-function _recordData4(identifier) {
-  assert(`No RecordData Yet Exists!`, _classPrivateFieldBase(this, _recordDatas)[_recordDatas].has(identifier));
-  return _classPrivateFieldBase(this, _recordDatas)[_recordDatas].get(identifier);
-}
 function constructResource(type, id, lid) {
   if (typeof type === 'object' && type !== null) {
     let resource = type;
@@ -1887,10 +2280,9 @@ class LegacyWrapper {
       this._scheduleNotification(identifier, key);
       return;
     }
+
+    // @ts-expect-error
     this._store.notifications.notify(identifier, namespace, key);
-    if (namespace === 'state') {
-      this._store.recordArrayManager.identifierChanged(identifier);
-    }
   }
   notifyErrorsChange(type, id, lid) {
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
@@ -2006,7 +2398,6 @@ class LegacyWrapper {
     const resource = constructResource(type, id, lid);
     const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
     this._store.notifications.notify(identifier, 'state');
-    this._store.recordArrayManager.identifierChanged(identifier);
   }
   recordDataFor(type, id, lid) {
     let identifier;
@@ -2029,12 +2420,14 @@ class LegacyWrapper {
       assert(`Expected a stable identifier`, isStableIdentifier(type));
       identifier = type;
     }
-    const recordData = this._store._instanceCache.getRecordData(identifier);
-    if (!id && !lid) {
-      recordData.clientDidCreate(identifier);
-      this._store.recordArrayManager.identifierAdded(identifier);
+    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_CREATE_RECORD_DATA_FOR_HOOK) ? this._store._instanceCache.getResourceCache(identifier) : this._store.cache;
+    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
+      if (!id && !lid && typeof type === 'string') {
+        cache.clientDidCreate(identifier);
+        this._store.recordArrayManager.identifierAdded(identifier);
+      }
     }
-    return recordData;
+    return cache;
   }
   setRecordId(type, id, lid) {
     let identifier;
@@ -2154,17 +2547,27 @@ class V2CacheStoreWrapper {
       this._scheduleNotification(identifier, key);
       return;
     }
+
+    // @ts-expect-error
     this._store.notifications.notify(identifier, namespace, key);
-    if (namespace === 'state') {
-      this._store.recordArrayManager.identifierChanged(identifier);
-    }
   }
   getSchemaDefinitionService() {
     return this._store.getSchemaDefinitionService();
   }
   recordDataFor(identifier) {
+    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_CREATE_RECORD_DATA_FOR_HOOK)) {
+      deprecate(`StoreWrapper.recordDataFor is deprecated. With Singleton Cache, this method is no longer needed as the caller is its own cache reference.`, false, {
+        for: '@ember-data/store',
+        id: 'ember-data:deprecate-record-data-for',
+        since: {
+          available: '4.10',
+          enabled: '4.10'
+        },
+        until: '5.0'
+      });
+    }
     assert(`Expected a stable identifier`, isStableIdentifier(identifier));
-    return this._store._instanceCache.getRecordData(identifier);
+    return macroCondition(getOwnConfig().deprecations.DEPRECATE_CREATE_RECORD_DATA_FOR_HOOK) ? this._store._instanceCache.getResourceCache(identifier) : void 0;
   }
   setRecordId(identifier, id) {
     assert(`Expected a stable identifier`, isStableIdentifier(identifier));
@@ -2183,496 +2586,24 @@ class V2CacheStoreWrapper {
   }
 }
 const CacheStoreWrapper = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS) ? LegacyWrapper : V2CacheStoreWrapper;
+let _peekGraph;
+if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
+  let __peekGraph;
+  _peekGraph = wrapper => {
+    let a = importSync('@ember-data/graph/-private').peekGraph;
+    __peekGraph = __peekGraph || a;
+    return __peekGraph(wrapper);
+  };
+}
 
 /**
   @module @ember-data/store
 */
-/**
-  Snapshot is not directly instantiable.
-  Instances are provided to a consuming application's
-  adapters and serializers for certain requests.
-
-  @class Snapshot
-  @public
-*/
-class Snapshot {
-  /**
-   * @method constructor
-   * @constructor
-   * @private
-   * @param options
-   * @param identifier
-   * @param _store
-   */
-  constructor(options, identifier, store) {
-    this._store = store;
-    this.__attributes = null;
-    this._belongsToRelationships = Object.create(null);
-    this._belongsToIds = Object.create(null);
-    this._hasManyRelationships = Object.create(null);
-    this._hasManyIds = Object.create(null);
-    const hasRecord = !!store._instanceCache.peek({
-      identifier,
-      bucket: 'record'
-    });
-    this.modelName = identifier.type;
 
-    /**
-      The unique RecordIdentifier associated with this Snapshot.
-       @property identifier
-      @public
-      @type {StableRecordIdentifier}
-    */
-    this.identifier = identifier;
-
-    /*
-      If the we do not yet have a record, then we are
-      likely a snapshot being provided to a find request, so we
-      populate __attributes lazily. Else, to preserve the "moment
-      in time" in which a snapshot is created, we greedily grab
-      the values.
-     */
-    if (hasRecord) {
-      this._attributes;
-    }
-
-    /**
-     The id of the snapshot's underlying record
-      Example
-      ```javascript
-     // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
-     postSnapshot.id; // => '1'
-     ```
-      @property id
-     @type {String}
-     @public
-     */
-    this.id = identifier.id;
-
-    /**
-     A hash of adapter options
-     @property adapterOptions
-     @type {Object}
-     @public
-     */
-    this.adapterOptions = options.adapterOptions;
-
-    /**
-     If `include` was passed to the options hash for the request, the value
-     would be available here.
-      @property include
-     @type {String|Array}
-     @public
-     */
-    this.include = options.include;
-
-    /**
-     The name of the type of the underlying record for this snapshot, as a string.
-      @property modelName
-     @type {String}
-     @public
-     */
-    this.modelName = identifier.type;
-    if (hasRecord) {
-      this._changedAttributes = this._store._instanceCache.getRecordData(identifier).changedAttrs(identifier);
-    }
-  }
-
-  /**
-   The underlying record for this snapshot. Can be used to access methods and
-   properties defined on the record.
-    Example
-    ```javascript
-   let json = snapshot.record.toJSON();
-   ```
-    @property record
-   @type {Model}
-   @public
-   */
-  get record() {
-    return this._store._instanceCache.getRecord(this.identifier);
-  }
-  get _attributes() {
-    if (this.__attributes !== null) {
-      return this.__attributes;
-    }
-    let attributes = this.__attributes = Object.create(null);
-    const {
-      identifier
-    } = this;
-    let attrs = Object.keys(this._store.getSchemaDefinitionService().attributesDefinitionFor(identifier));
-    let recordData = this._store._instanceCache.getRecordData(identifier);
-    attrs.forEach(keyName => {
-      attributes[keyName] = recordData.getAttr(identifier, keyName);
-    });
-    return attributes;
-  }
-
-  /**
-   The type of the underlying record for this snapshot, as a Model.
-    @property type
-    @public
-    @deprecated
-   @type {Model}
-   */
-
-  get isNew() {
-    const recordData = this._store._instanceCache.peek({
-      identifier: this.identifier,
-      bucket: 'recordData'
-    });
-    return recordData?.isNew(this.identifier) || false;
-  }
-
-  /**
-   Returns the value of an attribute.
-    Example
-    ```javascript
-   // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
-   postSnapshot.attr('author'); // => 'Tomster'
-   postSnapshot.attr('title'); // => 'Ember.js rocks'
-   ```
-    Note: Values are loaded eagerly and cached when the snapshot is created.
-    @method attr
-   @param {String} keyName
-   @return {Object} The attribute value or undefined
-   @public
-   */
-  attr(keyName) {
-    if (keyName in this._attributes) {
-      return this._attributes[keyName];
-    }
-    assert(`Model '${this.identifier}' has no attribute named '${keyName}' defined.`, false);
-  }
-
-  /**
-   Returns all attributes and their corresponding values.
-    Example
-    ```javascript
-   // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
-   postSnapshot.attributes(); // => { author: 'Tomster', title: 'Ember.js rocks' }
-   ```
-    @method attributes
-   @return {Object} All attributes of the current snapshot
-   @public
-   */
-  attributes() {
-    return {
-      ...this._attributes
-    };
-  }
-
-  /**
-   Returns all changed attributes and their old and new values.
-    Example
-    ```javascript
-   // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
-   postModel.set('title', 'Ember.js rocks!');
-   postSnapshot.changedAttributes(); // => { title: ['Ember.js rocks', 'Ember.js rocks!'] }
-   ```
-    @method changedAttributes
-   @return {Object} All changed attributes of the current snapshot
-   @public
-   */
-  changedAttributes() {
-    let changedAttributes = Object.create(null);
-    if (!this._changedAttributes) {
-      return changedAttributes;
-    }
-    let changedAttributeKeys = Object.keys(this._changedAttributes);
-    for (let i = 0, length = changedAttributeKeys.length; i < length; i++) {
-      let key = changedAttributeKeys[i];
-      changedAttributes[key] = this._changedAttributes[key].slice();
-    }
-    return changedAttributes;
-  }
-
-  /**
-   Returns the current value of a belongsTo relationship.
-    `belongsTo` takes an optional hash of options as a second parameter,
-   currently supported options are:
-    - `id`: set to `true` if you only want the ID of the related record to be
-   returned.
-    Example
-    ```javascript
-   // store.push('post', { id: 1, title: 'Hello World' });
-   // store.createRecord('comment', { body: 'Lorem ipsum', post: post });
-   commentSnapshot.belongsTo('post'); // => Snapshot
-   commentSnapshot.belongsTo('post', { id: true }); // => '1'
-    // store.push('comment', { id: 1, body: 'Lorem ipsum' });
-   commentSnapshot.belongsTo('post'); // => undefined
-   ```
-    Calling `belongsTo` will return a new Snapshot as long as there's any known
-   data for the relationship available, such as an ID. If the relationship is
-   known but unset, `belongsTo` will return `null`. If the contents of the
-   relationship is unknown `belongsTo` will return `undefined`.
-    Note: Relationships are loaded lazily and cached upon first access.
-    @method belongsTo
-   @param {String} keyName
-   @param {Object} [options]
-   @public
-   @return {(Snapshot|String|null|undefined)} A snapshot or ID of a known
-   relationship or null if the relationship is known but unset. undefined
-   will be returned if the contents of the relationship is unknown.
-   */
-  belongsTo(keyName, options) {
-    let returnModeIsId = !!(options && options.id);
-    let result;
-    let store = this._store;
-    if (returnModeIsId === true && keyName in this._belongsToIds) {
-      return this._belongsToIds[keyName];
-    }
-    if (returnModeIsId === false && keyName in this._belongsToRelationships) {
-      return this._belongsToRelationships[keyName];
-    }
-    let relationshipMeta = store.getSchemaDefinitionService().relationshipsDefinitionFor({
-      type: this.modelName
-    })[keyName];
-    assert(`Model '${this.identifier}' has no belongsTo relationship named '${keyName}' defined.`, relationshipMeta && relationshipMeta.kind === 'belongsTo');
-
-    // TODO @runspired it seems this code branch would not work with CUSTOM_MODEL_CLASSes
-    // this check is not a regression in behavior because relationships don't currently
-    // function without access to intimate API contracts between RecordData and Model.
-    // This is a requirement we should fix as soon as the relationship layer does not require
-    // this intimate API usage.
-    if (macroCondition(!dependencySatisfies("@ember-data/json-api", "*"))) {
-      assert(`snapshot.belongsTo only supported when using the package @ember-data/json-api`);
-    }
-    const graphFor = importSync('@ember-data/graph/-private').graphFor;
-    const {
-      identifier
-    } = this;
-    const relationship = graphFor(this._store).get(identifier, keyName);
-    assert(`You looked up the ${keyName} belongsTo relationship for { type: ${identifier.type}, id: ${identifier.id}, lid: ${identifier.lid} but no such relationship was found.`, relationship);
-    assert(`You looked up the ${keyName} belongsTo relationship for { type: ${identifier.type}, id: ${identifier.id}, lid: ${identifier.lid} but that relationship is a hasMany.`, relationship.definition.kind === 'belongsTo');
-    let value = relationship.getData();
-    let data = value && value.data;
-    let inverseIdentifier = data ? store.identifierCache.getOrCreateRecordIdentifier(data) : null;
-    if (value && value.data !== undefined) {
-      if (inverseIdentifier && !store._instanceCache.getRecordData(inverseIdentifier).isDeleted(inverseIdentifier)) {
-        if (returnModeIsId) {
-          result = inverseIdentifier.id;
-        } else {
-          result = store._instanceCache.createSnapshot(inverseIdentifier);
-        }
-      } else {
-        result = null;
-      }
-    }
-    if (returnModeIsId) {
-      this._belongsToIds[keyName] = result;
-    } else {
-      this._belongsToRelationships[keyName] = result;
-    }
-    return result;
-  }
-
-  /**
-   Returns the current value of a hasMany relationship.
-    `hasMany` takes an optional hash of options as a second parameter,
-   currently supported options are:
-    - `ids`: set to `true` if you only want the IDs of the related records to be
-   returned.
-    Example
-    ```javascript
-   // store.push('post', { id: 1, title: 'Hello World', comments: [2, 3] });
-   postSnapshot.hasMany('comments'); // => [Snapshot, Snapshot]
-   postSnapshot.hasMany('comments', { ids: true }); // => ['2', '3']
-    // store.push('post', { id: 1, title: 'Hello World' });
-   postSnapshot.hasMany('comments'); // => undefined
-   ```
-    Note: Relationships are loaded lazily and cached upon first access.
-    @method hasMany
-   @param {String} keyName
-   @param {Object} [options]
-   @public
-   @return {(Array|undefined)} An array of snapshots or IDs of a known
-   relationship or an empty array if the relationship is known but unset.
-   undefined will be returned if the contents of the relationship is unknown.
-   */
-  hasMany(keyName, options) {
-    let returnModeIsIds = !!(options && options.ids);
-    let results;
-    let cachedIds = this._hasManyIds[keyName];
-    let cachedSnapshots = this._hasManyRelationships[keyName];
-    if (returnModeIsIds === true && keyName in this._hasManyIds) {
-      return cachedIds;
-    }
-    if (returnModeIsIds === false && keyName in this._hasManyRelationships) {
-      return cachedSnapshots;
-    }
-    let store = this._store;
-    let relationshipMeta = store.getSchemaDefinitionService().relationshipsDefinitionFor({
-      type: this.modelName
-    })[keyName];
-    assert(`Model '${this.identifier}' has no hasMany relationship named '${keyName}' defined.`, relationshipMeta && relationshipMeta.kind === 'hasMany');
-
-    // TODO @runspired it seems this code branch would not work with CUSTOM_MODEL_CLASSes
-    // this check is not a regression in behavior because relationships don't currently
-    // function without access to intimate API contracts between RecordData and Model.
-    // This is a requirement we should fix as soon as the relationship layer does not require
-    // this intimate API usage.
-    if (macroCondition(!dependencySatisfies("@ember-data/json-api", "*"))) {
-      assert(`snapshot.hasMany only supported when using the package @ember-data/json-api`);
-    }
-    const graphFor = importSync('@ember-data/graph/-private').graphFor;
-    const {
-      identifier
-    } = this;
-    const relationship = graphFor(this._store).get(identifier, keyName);
-    assert(`You looked up the ${keyName} hasMany relationship for { type: ${identifier.type}, id: ${identifier.id}, lid: ${identifier.lid} but no such relationship was found.`, relationship);
-    assert(`You looked up the ${keyName} hasMany relationship for { type: ${identifier.type}, id: ${identifier.id}, lid: ${identifier.lid} but that relationship is a belongsTo.`, relationship.definition.kind === 'hasMany');
-    let value = relationship.getData();
-    if (value.data) {
-      results = [];
-      value.data.forEach(member => {
-        let inverseIdentifier = store.identifierCache.getOrCreateRecordIdentifier(member);
-        if (!store._instanceCache.getRecordData(inverseIdentifier).isDeleted(inverseIdentifier)) {
-          if (returnModeIsIds) {
-            results.push(inverseIdentifier.id);
-          } else {
-            results.push(store._instanceCache.createSnapshot(inverseIdentifier));
-          }
-        }
-      });
-    }
-
-    // we assign even if `undefined` so that we don't reprocess the relationship
-    // on next access. This works with the `keyName in` checks above.
-    if (returnModeIsIds) {
-      this._hasManyIds[keyName] = results;
-    } else {
-      this._hasManyRelationships[keyName] = results;
-    }
-    return results;
-  }
-
-  /**
-    Iterates through all the attributes of the model, calling the passed
-    function on each attribute.
-     Example
-     ```javascript
-    snapshot.eachAttribute(function(name, meta) {
-      // ...
-    });
-    ```
-     @method eachAttribute
-    @param {Function} callback the callback to execute
-    @param {Object} [binding] the value to which the callback's `this` should be bound
-    @public
-  */
-  eachAttribute(callback, binding) {
-    let attrDefs = this._store.getSchemaDefinitionService().attributesDefinitionFor(this.identifier);
-    Object.keys(attrDefs).forEach(key => {
-      callback.call(binding, key, attrDefs[key]);
-    });
-  }
-
-  /**
-    Iterates through all the relationships of the model, calling the passed
-    function on each relationship.
-     Example
-     ```javascript
-    snapshot.eachRelationship(function(name, relationship) {
-      // ...
-    });
-    ```
-     @method eachRelationship
-    @param {Function} callback the callback to execute
-    @param {Object} [binding] the value to which the callback's `this` should be bound
-    @public
-  */
-  eachRelationship(callback, binding) {
-    let relationshipDefs = this._store.getSchemaDefinitionService().relationshipsDefinitionFor(this.identifier);
-    Object.keys(relationshipDefs).forEach(key => {
-      callback.call(binding, key, relationshipDefs[key]);
-    });
-  }
-
-  /**
-    Serializes the snapshot using the serializer for the model.
-     Example
-     ```app/adapters/application.js
-    import Adapter from '@ember-data/adapter';
-     export default Adapter.extend({
-      createRecord(store, type, snapshot) {
-        let data = snapshot.serialize({ includeId: true });
-        let url = `/${type.modelName}`;
-         return fetch(url, {
-          method: 'POST',
-          body: data,
-        }).then((response) => response.json())
-      }
-    });
-    ```
-     @method serialize
-    @param {Object} options
-    @return {Object} an object whose values are primitive JSON values only
-    @public
-   */
-  serialize(options) {
-    const serializer = this._store.serializerFor(this.modelName);
-    assert(`Cannot serialize record, no serializer found`, serializer);
-    return serializer.serialize(this, options);
-  }
-}
-if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS)) {
-  Object.defineProperty(Snapshot.prototype, 'type', {
-    get() {
-      deprecate(`Using Snapshot.type to access the ModelClass for a record is deprecated. Use store.modelFor(<modelName>) instead.`, false, {
-        id: 'ember-data:deprecate-snapshot-model-class-access',
-        until: '5.0',
-        for: 'ember-data',
-        since: {
-          available: '4.5.0',
-          enabled: '4.5.0'
-        }
-      });
-      return this._store.modelFor(this.identifier.type);
-    }
-  });
-}
-function assertIdentifierHasId(identifier) {
-  assert(`Attempted to schedule a fetch for a record without an id.`, identifier.id !== null);
-}
-
-/*
- * Returns the RecordData instance associated with a given
- * Model or Identifier
- */
-
-const RecordDataForIdentifierCache = new Map();
-function setRecordDataFor(identifier, recordData) {
-  assert(`Illegal set of identifier`, !RecordDataForIdentifierCache.has(identifier) || RecordDataForIdentifierCache.get(identifier) === recordData);
-  RecordDataForIdentifierCache.set(identifier, recordData);
-}
-function removeRecordDataFor(identifier) {
-  RecordDataForIdentifierCache.delete(identifier);
-}
-function recordDataFor(instance) {
-  if (RecordDataForIdentifierCache.has(instance)) {
-    return RecordDataForIdentifierCache.get(instance);
-  }
-  return null;
-}
-let _peekGraph;
-if (macroCondition(dependencySatisfies("@ember-data/graph", "*"))) {
-  let __peekGraph;
-  _peekGraph = wrapper => {
-    let a = importSync('@ember-data/graph/-private').peekGraph;
-    __peekGraph = __peekGraph || a;
-    return __peekGraph(wrapper);
-  };
-}
-
-/**
-  @module @ember-data/store
-*/
-
-const RecordCache = new Map();
-function peekRecordIdentifier(record) {
-  return RecordCache.get(record);
-}
+const RecordCache = new Map();
+function peekRecordIdentifier(record) {
+  return RecordCache.get(record);
+}
 
 /**
   Retrieves the unique referentially-stable [RecordIdentifier](/ember-data/release/classes/StableRecordIdentifier)
@@ -2698,7 +2629,7 @@ function recordIdentifierFor(record) {
   return RecordCache.get(record);
 }
 function setRecordIdentifier(record, identifier) {
-  if (macroCondition(isDevelopingApp())) {
+  if (macroCondition(getOwnConfig().env.DEBUG)) {
     if (RecordCache.has(record) && RecordCache.get(record) !== identifier) {
       throw new Error(`${String(record)} was already assigned an identifier`);
     }
@@ -2724,16 +2655,18 @@ class InstanceCache {
   constructor(store) {
     this.__instances = {
       record: new Map(),
-      recordData: new Map(),
+      resourceCache: new Map(),
       reference: new WeakMap()
     };
     this.store = store;
     this._storeWrapper = new CacheStoreWrapper(this.store);
-    this.__recordDataFor = resource => {
-      // TODO enforce strict
-      const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource);
-      return this.getRecordData(identifier);
-    };
+    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_CREATE_RECORD_DATA_FOR_HOOK)) {
+      this.__cacheFor = resource => {
+        // TODO enforce strict
+        const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource);
+        return this.getResourceCache(identifier);
+      };
+    }
     store.identifierCache.__configureMerge((identifier, matchedIdentifier, resourceData) => {
       let keptIdentifier = identifier;
       if (identifier.id !== matchedIdentifier.id) {
@@ -2746,11 +2679,11 @@ class InstanceCache {
       // check for duplicate entities
       let keptHasRecord = this.__instances.record.has(keptIdentifier);
       let staleHasRecord = this.__instances.record.has(staleIdentifier);
-      let keptRecordData = this.__instances.recordData.get(keptIdentifier) || null;
-      let staleRecordData = this.__instances.recordData.get(staleIdentifier) || null;
+      let keptResourceCache = this.__instances.resourceCache.get(keptIdentifier) || null;
+      let staleResourceCache = this.__instances.resourceCache.get(staleIdentifier) || null;
 
       // we cannot merge entities when both have records
-      // (this may not be strictly true, we could probably swap the recordData the record points at)
+      // (this may not be strictly true, we could probably swap the cache data the record points at)
       if (keptHasRecord && staleHasRecord) {
         // TODO we probably don't need to throw these errors anymore
         // we can probably just "swap" what data source the abandoned
@@ -2761,23 +2694,27 @@ class InstanceCache {
         }
         assert(`Failed to update the RecordIdentifier '${identifier.type}:${String(identifier.id)} (${identifier.lid})' to merge with the detected duplicate identifier '${matchedIdentifier.type}:${String(matchedIdentifier.id)} (${String(matchedIdentifier.lid)})'`);
       }
-      let recordData = keptRecordData || staleRecordData;
-      if (recordData) {
-        recordData.sync({
+      let resourceCache = keptResourceCache || staleResourceCache;
+      if (resourceCache) {
+        resourceCache.patch({
+          op: 'mergeIdentifiers',
+          record: staleIdentifier,
+          value: keptIdentifier
+        });
+      } else if (macroCondition(!getOwnConfig().deprecations.DEPRECATE_CREATE_RECORD_DATA_FOR_HOOK)) {
+        this.store.cache.patch({
           op: 'mergeIdentifiers',
           record: staleIdentifier,
           value: keptIdentifier
         });
-      } else if (macroCondition(dependencySatisfies("@ember-data/json-api", "*"))) {
-        // TODO notify cache always, this requires it always being a singleton
-        // and not ever specific to one record-data
-        this.store.__private_singleton_recordData?.sync({
+      } else if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
+        this.store.cache.patch({
           op: 'mergeIdentifiers',
           record: staleIdentifier,
           value: keptIdentifier
         });
       }
-      if (staleRecordData === null) {
+      if (staleResourceCache === null) {
         return keptIdentifier;
       }
 
@@ -2805,10 +2742,27 @@ class InstanceCache {
     let record = this.__instances.record.get(identifier);
     if (!record) {
       assert(`Cannot create a new record instance while the store is being destroyed`, !this.store.isDestroying && !this.store.isDestroyed);
-      const recordData = this.getRecordData(identifier);
-      record = this.store.instantiateRecord(identifier, properties || {}, this.__recordDataFor, this.store.notifications);
+      const cache = this.getResourceCache(identifier);
+      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_INSTANTIATE_RECORD_ARGS)) {
+        if (this.store.instantiateRecord.length > 2) {
+          deprecate(`Expected store.instantiateRecord to have an arity of 2. recordDataFor and notificationManager args have been deprecated.`, false, {
+            for: '@ember-data/store',
+            id: 'ember-data:deprecate-instantiate-record-args',
+            since: {
+              available: '4.12',
+              enabled: '4.12'
+            },
+            until: '5.0'
+          });
+        }
+        record = this.store.instantiateRecord(identifier, properties || {},
+        // @ts-expect-error
+        this.__cacheFor, this.store.notifications);
+      } else {
+        record = this.store.instantiateRecord(identifier, properties || {});
+      }
       setRecordIdentifier(record, identifier);
-      setRecordDataFor(record, recordData);
+      setCacheFor(record, cache);
       StoreMap.set(record, this.store);
       this.__instances.record.set(identifier, record);
       if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
@@ -2818,49 +2772,49 @@ class InstanceCache {
     }
     return record;
   }
-  getRecordData(identifier) {
-    let recordData = this.__instances.recordData.get(identifier);
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
-      if (!recordData && this.store.createRecordDataFor.length > 2) {
-        deprecate(`Store.createRecordDataFor(<type>, <id>, <lid>, <storeWrapper>) has been deprecated in favor of Store.createRecordDataFor(<identifier>, <storeWrapper>)`, false, {
-          id: 'ember-data:deprecate-v1cache-store-apis',
-          for: 'ember-data',
-          until: '5.0',
-          since: {
-            enabled: '4.7',
-            available: '4.7'
-          }
-        });
-        let recordDataInstance = this.store.createRecordDataFor(identifier.type, identifier.id,
-        // @ts-expect-error
-        identifier.lid, this._storeWrapper);
-        if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA)) {
-          recordData = new NonSingletonCacheManager(this.store, recordDataInstance, identifier);
-        } else {
-          recordData = this.__cacheManager = this.__cacheManager || new NonSingletonCacheManager(this.store, recordDataInstance, identifier);
-        }
-      }
+  getResourceCache(identifier) {
+    if (macroCondition(!getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA)) {
+      const cache = this.store.cache;
+      setCacheFor(identifier, cache);
+      this.__instances.resourceCache.set(identifier, cache);
+      return cache;
     }
-    if (!recordData) {
-      let recordDataInstance = this.store.createRecordDataFor(identifier, this._storeWrapper);
-      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA)) {
-        recordData = new NonSingletonCacheManager(this.store, recordDataInstance, identifier);
-      } else {
-        if (macroCondition(isDevelopingApp())) {
-          recordData = this.__cacheManager = this.__cacheManager || new SingletonCacheManager();
-          recordData._addRecordData(identifier, recordDataInstance);
-        } else {
-          recordData = recordDataInstance;
+    let cache = this.__instances.resourceCache.get(identifier);
+    if (cache) {
+      return cache;
+    }
+    if (this.store.createRecordDataFor) {
+      deprecate(`Store.createRecordDataFor(<type>, <id>, <lid>, <storeWrapper>) has been deprecated in favor of Store.createCache(<storeWrapper>)`, false, {
+        id: 'ember-data:deprecate-v1-cache',
+        for: 'ember-data',
+        until: '5.0',
+        since: {
+          enabled: '4.12',
+          available: '4.12'
+        }
+      });
+      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
+        if (this.store.createRecordDataFor.length > 2) {
+          let cacheInstance = this.store.createRecordDataFor(identifier.type, identifier.id,
+          // @ts-expect-error
+          identifier.lid, this._storeWrapper);
+          cache = new NonSingletonCacheManager(this.store, cacheInstance, identifier);
         }
       }
-      setRecordDataFor(identifier, recordData);
-      this.__instances.recordData.set(identifier, recordData);
-      if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
-        // eslint-disable-next-line no-console
-        console.log(`InstanceCache: created RecordData for ${String(identifier)}`);
+      if (!cache) {
+        let cacheInstance = this.store.createRecordDataFor(identifier, this._storeWrapper);
+        cache = cacheInstance.version === '2' ? cacheInstance : new NonSingletonCacheManager(this.store, cacheInstance, identifier);
       }
+    } else {
+      cache = this.store.cache;
     }
-    return recordData;
+    setCacheFor(identifier, cache);
+    this.__instances.resourceCache.set(identifier, cache);
+    if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+      // eslint-disable-next-line no-console
+      console.log(`InstanceCache: created Cache for ${String(identifier)}`);
+    }
+    return cache;
   }
   getReference(identifier) {
     let cache = this.__instances.reference;
@@ -2872,16 +2826,16 @@ class InstanceCache {
     return reference;
   }
   recordIsLoaded(identifier, filterDeleted = false) {
-    const recordData = this.__instances.recordData.get(identifier);
-    if (!recordData) {
+    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this.__instances.resourceCache.get(identifier) : this.cache;
+    if (!cache) {
       return false;
     }
-    const isNew = recordData.isNew(identifier);
-    const isEmpty = recordData.isEmpty(identifier);
+    const isNew = cache.isNew(identifier);
+    const isEmpty = cache.isEmpty(identifier);
 
     // if we are new we must consider ourselves loaded
     if (isNew) {
-      return !recordData.isDeleted(identifier);
+      return !cache.isDeleted(identifier);
     }
     // even if we have a past request, if we are now empty we are not loaded
     // typically this is true after an unloadRecord call
@@ -2890,43 +2844,28 @@ class InstanceCache {
     // we should consider allowing for something to be loaded that is simply "not empty".
     // which is how RecordState currently handles this case; however, RecordState is buggy
     // in that it does not account for unloading.
-    return filterDeleted && recordData.isDeletionCommitted(identifier) ? false : !isEmpty;
-
-    /*
-    const req = this.store.getRequestStateService();
-    const fulfilled = req.getLastRequestForRecord(identifier);
-    const isLocallyLoaded = !isEmpty;
-    const isLoading =
-      !isLocallyLoaded &&
-      fulfilled === null &&
-      req.getPendingRequestsForRecord(identifier).some((req) => req.type === 'query');
-     if (isEmpty || (filterDeleted && recordData.isDeletionCommitted(identifier)) || isLoading) {
-      return false;
-    }
-     return true;
-    */
-  }
-
-  createSnapshot(identifier, options = {}) {
-    return new Snapshot(options, identifier, this.store);
+    return filterDeleted && cache.isDeletionCommitted(identifier) ? false : !isEmpty;
   }
   disconnect(identifier) {
     const record = this.__instances.record.get(identifier);
     assert('Cannot destroy record while it is still materialized', !record || record.isDestroyed || record.isDestroying);
-    if (macroCondition(dependencySatisfies("@ember-data/graph", "*"))) {
+    if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
       let graph = _peekGraph(this.store);
       if (graph) {
         graph.remove(identifier);
       }
     }
     this.store.identifierCache.forgetRecordIdentifier(identifier);
+    this.__instances.resourceCache.delete(identifier);
+    removeRecordDataFor(identifier);
+    this.store._requestCache._clearEntries(identifier);
     if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
       // eslint-disable-next-line no-console
       console.log(`InstanceCache: disconnected ${String(identifier)}`);
     }
   }
   unloadRecord(identifier) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       const requests = this.store.getRequestStateService().getPendingRequestsForRecord(identifier);
       if (requests.some(req => {
         return req.type === 'mutation';
@@ -2942,7 +2881,7 @@ class InstanceCache {
     // TODO is this join still necessary?
     this.store._join(() => {
       const record = this.__instances.record.get(identifier);
-      const recordData = this.__instances.recordData.get(identifier);
+      const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this.__instances.resourceCache.get(identifier) : this.cache;
       if (record) {
         this.store.teardownRecord(record);
         this.__instances.record.delete(identifier);
@@ -2954,20 +2893,18 @@ class InstanceCache {
           console.log(`InstanceCache: destroyed record for ${String(identifier)}`);
         }
       }
-      let removeFromRecordArray = true;
-      if (recordData) {
-        removeFromRecordArray = !recordData.isDeletionCommitted(identifier);
-        recordData.unloadRecord(identifier);
-        this.__instances.recordData.delete(identifier);
+      if (cache) {
+        cache.unloadRecord(identifier);
+        this.__instances.resourceCache.delete(identifier);
         removeRecordDataFor(identifier);
+        if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+          // eslint-disable-next-line no-console
+          console.log(`InstanceCache: destroyed cache for ${String(identifier)}`);
+        }
       } else {
-        removeFromRecordArray = false;
         this.disconnect(identifier);
       }
-      this.store._fetchManager.clearEntries(identifier);
-      if (removeFromRecordArray) {
-        this.store.recordArrayManager.identifierRemoved(identifier);
-      }
+      this.store._requestCache._clearEntries(identifier);
       if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
         // eslint-disable-next-line no-console
         console.log(`InstanceCache: unloaded RecordData for ${String(identifier)}`);
@@ -2977,43 +2914,28 @@ class InstanceCache {
     });
   }
   clear(type) {
-    const typeCache = this.store.identifierCache._cache.types;
+    const cache = this.store.identifierCache._cache;
     if (type === undefined) {
-      this.__instances.recordData.forEach((value, identifier) => {
+      // it would be cool if we could just de-ref cache here
+      // but probably would require WeakRef models to do so.
+      cache.lids.forEach(identifier => {
         this.unloadRecord(identifier);
       });
     } else {
+      const typeCache = cache.types;
       let identifiers = typeCache[type]?.lid;
-      const rds = this.__instances.recordData;
+      // const rds = this.__instances.resourceCache;
       if (identifiers) {
         identifiers.forEach(identifier => {
-          if (rds.has(identifier)) {
-            this.unloadRecord(identifier);
-          }
+          // if (rds.has(identifier)) {
+          this.unloadRecord(identifier);
+          // }
           // TODO we don't remove the identifier, should we?
         });
       }
     }
   }
 
-  // TODO this should move into the network layer
-  _fetchDataIfNeededForIdentifier(identifier, options = {}) {
-    // pre-loading will change the isEmpty value
-    const isEmpty = _isEmpty(this, identifier);
-    const isLoading = _isLoading(this, identifier);
-    let promise;
-    if (isEmpty) {
-      assertIdentifierHasId(identifier);
-      promise = this.store._fetchManager.scheduleFetch(identifier, options);
-    } else if (isLoading) {
-      promise = this.store._fetchManager.getPendingFetch(identifier, options);
-      assert(`Expected to find a pending request for a record in the loading state, but found none`, promise);
-    } else {
-      promise = resolve(identifier);
-    }
-    return promise;
-  }
-
   // TODO this should move into something coordinating operations
   setRecordId(identifier, id) {
     const {
@@ -3052,12 +2974,13 @@ class InstanceCache {
       });
     }
 
-    // TODO update recordData if needed ?
+    // TODO update resource cache if needed ?
     // TODO handle consequences of identifier merge for notifications
     this.store.notifications.notify(identifier, 'identity');
   }
 
-  // TODO this should move into something coordinating operations
+  // TODO ths should be wrapped in a deprecation flag since cache.put
+  // handles this the rest of the time
   loadData(data) {
     let modelName = data.type;
     assert(`You must include an 'id' for ${modelName} in an object passed to 'push'`, data.id !== null && data.id !== undefined && data.id !== '');
@@ -3081,24 +3004,18 @@ class InstanceCache {
     } else {
       identifier = this.store.identifierCache.getOrCreateRecordIdentifier(data);
     }
-    const recordData = this.getRecordData(identifier);
-    if (recordData.isNew(identifier)) {
-      this.store.notifications.notify(identifier, 'identity');
-    }
+    const cache = this.getResourceCache(identifier);
     const hasRecord = this.__instances.record.has(identifier);
-    recordData.pushData(identifier, data, hasRecord);
-    if (!isUpdate) {
-      this.store.recordArrayManager.identifierAdded(identifier);
-    }
+    cache.upsert(identifier, data, hasRecord);
     return identifier;
   }
 }
-function _recordDataIsFullDeleted(identifier, recordData) {
-  return recordData.isDeletionCommitted(identifier) || recordData.isNew(identifier) && recordData.isDeleted(identifier);
+function _resourceIsFullDeleted(identifier, cache) {
+  return cache.isDeletionCommitted(identifier) || cache.isNew(identifier) && cache.isDeleted(identifier);
 }
-function recordDataIsFullyDeleted(cache, identifier) {
-  let recordData = cache.__instances.recordData.get(identifier);
-  return !recordData || _recordDataIsFullDeleted(identifier, recordData);
+function resourceIsFullyDeleted(instanceCache, identifier) {
+  const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? instanceCache.__instances.resourceCache.get(identifier) : instanceCache.cache;
+  return !cache || _resourceIsFullDeleted(identifier, cache);
 }
 
 /*
@@ -3133,7 +3050,12 @@ function preloadData(store, identifier, preload) {
       jsonPayload.attributes[key] = preloadValue;
     }
   });
-  store._instanceCache.getRecordData(identifier).pushData(identifier, jsonPayload);
+  const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? store._instanceCache.getResourceCache(identifier) : store.cache;
+  const hasRecord = Boolean(store._instanceCache.peek({
+    identifier,
+    bucket: 'record'
+  }));
+  cache.upsert(identifier, jsonPayload, hasRecord);
 }
 function preloadRelationship(schema, preloadValue) {
   const relatedType = schema.type;
@@ -3164,14 +3086,14 @@ function _convertPreloadRelationshipToJSON(value, type) {
   // and allow identifiers to be used
   return recordIdentifierFor(value);
 }
-function _isEmpty(cache, identifier) {
-  const recordData = cache.__instances.recordData.get(identifier);
-  if (!recordData) {
+function _isEmpty(instanceCache, identifier) {
+  const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? instanceCache.__instances.resourceCache.get(identifier) : instanceCache.cache;
+  if (!cache) {
     return true;
   }
-  const isNew = recordData.isNew(identifier);
-  const isDeleted = recordData.isDeleted(identifier);
-  const isEmpty = recordData.isEmpty(identifier);
+  const isNew = cache.isNew(identifier);
+  const isDeleted = cache.isDeleted(identifier);
+  const isEmpty = cache.isEmpty(identifier);
   return (!isNew || isDeleted) && isEmpty;
 }
 function _isLoading(cache, identifier) {
@@ -3185,10 +3107,10 @@ function _isLoading(cache, identifier) {
 function _clearCaches() {
   RecordCache.clear();
   StoreMap.clear();
-  RecordDataForIdentifierCache.clear();
+  CacheForIdentifierCache.clear();
 }
 let _modelForMixin;
-if (macroCondition(dependencySatisfies("@ember-data/model", "*"))) {
+if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
   let _found;
   _modelForMixin = function () {
     if (!_found) {
@@ -3276,7 +3198,7 @@ function getModelFactory(store, cache, normalizedModelName) {
   if (!factory) {
     let owner = getOwner(store);
     factory = owner.factoryFor(`model:${normalizedModelName}`);
-    if (macroCondition(dependencySatisfies("@ember-data/model", "*"))) {
+    if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
       if (!factory) {
         //Support looking up mixins as base types for polymorphic relationships
         factory = _modelForMixin(store, normalizedModelName);
@@ -3433,14 +3355,14 @@ let PromiseArray = (_dec = reads('content.meta'), (_class$1 = class PromiseArray
   writable: true,
   initializer: null
 }), _class$1));
-function _promiseObject(promise, label) {
+function _promiseObject(promise) {
   return PromiseObjectProxy.create({
-    promise: resolve(promise, label)
+    promise
   });
 }
-function _promiseArray(promise, label) {
+function _promiseArray(promise) {
   return PromiseArray.create({
-    promise: resolve(promise, label)
+    promise
   });
 }
 
@@ -3451,7 +3373,7 @@ const PROXIED_ARRAY_PROPS = ['length', '[]', 'firstObject', 'lastObject', 'meta'
 const PROXIED_OBJECT_PROPS = ['content', 'isPending', 'isSettled', 'isRejected', 'isFulfilled', 'promise', 'reason'];
 function promiseArray(promise) {
   const promiseObjectProxy = _promiseArray(promise);
-  if (macroCondition(!isDevelopingApp())) {
+  if (macroCondition(!getOwnConfig().env.DEBUG)) {
     return promiseObjectProxy;
   }
   const handler = {
@@ -3488,7 +3410,7 @@ function promiseArray(promise) {
 const ProxySymbolString = String(Symbol.for('PROXY_CONTENT'));
 function promiseObject(promise) {
   const promiseObjectProxy = _promiseObject(promise);
-  if (macroCondition(!isDevelopingApp())) {
+  if (macroCondition(!getOwnConfig().env.DEBUG)) {
     return promiseObjectProxy;
   }
   const handler = {
@@ -3544,6 +3466,7 @@ const IDENTIFIER_ARRAY_TAG = Symbol('#tag');
 const SOURCE = Symbol('#source');
 const MUTATE = Symbol('#update');
 const NOTIFY = Symbol('#notify');
+const IS_COLLECTION = Symbol.for('Collection');
 function notifyArray(arr) {
   arr[IDENTIFIER_ARRAY_TAG].ref = null;
   if (macroCondition(getOwnConfig().deprecations.DEPRECATE_COMPUTED_CHAINS)) {
@@ -3664,6 +3587,7 @@ let IdentifierArray = (_class3 = class IdentifierArray {
     this.isDestroying = false;
     this.isDestroyed = false;
     this._updatingPromise = null;
+    this[IS_COLLECTION] = true;
     this[IDENTIFIER_ARRAY_TAG] = new Tag();
     this[SOURCE] = void 0;
     // eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -3856,7 +3780,7 @@ let IdentifierArray = (_class3 = class IdentifierArray {
         }
         return false;
       };
-    } else if (macroCondition(isDevelopingApp())) {
+    } else if (macroCondition(getOwnConfig().env.DEBUG)) {
       const meta = Ember.meta(this);
       meta.hasMixin = mixin => {
         assert(`Do not call A() on EmberData RecordArrays`);
@@ -3903,6 +3827,7 @@ let IdentifierArray = (_class3 = class IdentifierArray {
     is finished.
    */
   _update() {
+    assert(`_update cannot be used with this array`, this.modelName);
     return this.store.findAll(this.modelName, {
       reload: true
     });
@@ -3973,6 +3898,8 @@ class Collection extends IdentifierArray {
     } = this;
 
     // 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);
     const promise = store.query(this.modelName, query, {
       _recordArray: this
     });
@@ -4113,7 +4040,7 @@ if (macroCondition(getOwnConfig().deprecations.DEPRECATE_ARRAY_LIKE)) {
     return this;
   };
   IdentifierArray.prototype.setObjects = function (objects) {
-    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'clear', 'length = 0');
+    deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'setObjects', '`arr.length = 0; arr.push(objects);`');
     assert(`${this.DEPRECATED_CLASS_NAME}.setObjects expects to receive an array as its argument`, Array.isArray(objects));
     this.splice(0, this.length);
     this.push(...objects);
@@ -4368,6 +4295,15 @@ class RecordArrayManager {
     this._pending = new Map();
     this._staged = new Map();
     this._identifiers = RecordArraysCache;
+    this._subscription = this.store.notifications.subscribe('resource', (identifier, type) => {
+      if (type === 'added') {
+        this.identifierAdded(identifier);
+      } else if (type === 'removed') {
+        this.identifierRemoved(identifier);
+      } else if (type === 'state') {
+        this.identifierChanged(identifier);
+      }
+    });
   }
   _syncArray(array) {
     const pending = this._pending.get(array);
@@ -4549,6 +4485,8 @@ class RecordArrayManager {
     this.clear();
     this._live.clear();
     this.isDestroyed = true;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    this.store.notifications.unsubscribe(this._subscription);
   }
 }
 function associate(array, identifiers) {
@@ -4616,125 +4554,22 @@ function sync(array, changes) {
   }
 }
 
-/**
-  @module @ember-data/store
-*/
-
-function _bind(fn, ...args) {
-  return function () {
-    return fn.apply(undefined, args);
-  };
-}
-function _guard(promise, test) {
-  let guarded = promise.finally(() => {
-    if (!test()) {
-      guarded._subscribers.length = 0;
-    }
-  });
-  return guarded;
-}
-function _objectIsAlive(object) {
-  return !(object.isDestroyed || object.isDestroying);
-}
-function guardDestroyedStore(promise, store, label) {
-  let token;
-  if (macroCondition(isDevelopingApp())) {
-    token = store._trackAsyncRequestStart(label);
-  }
-  let wrapperPromise = resolve(promise, label).then(_v => {
-    if (!_objectIsAlive(store)) {
-      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
-        deprecate(`A Promise did not resolve by the time the store was destroyed. This will error in a future release.`, false, {
-          id: 'ember-data:rsvp-unresolved-async',
-          until: '5.0',
-          for: '@ember-data/store',
-          since: {
-            available: '4.5',
-            enabled: '4.5'
-          }
-        });
-      }
-    }
-    return promise;
-  });
-  return _guard(wrapperPromise, () => {
-    if (macroCondition(isDevelopingApp())) {
-      store._trackAsyncRequestEnd(token);
-    }
-    return _objectIsAlive(store);
-  });
-}
-
-/**
-  This is a helper method that validates a JSON API top-level document
-
-  The format of a document is described here:
-  http://jsonapi.org/format/#document-top-level
-
-  @internal
-*/
-function validateDocumentStructure(doc) {
-  if (macroCondition(isDevelopingApp())) {
-    let errors = [];
-    if (!doc || typeof doc !== 'object') {
-      errors.push('Top level of a JSON API document must be an object');
-    } else {
-      if (!('data' in doc) && !('errors' in doc) && !('meta' in doc)) {
-        errors.push('One or more of the following keys must be present: "data", "errors", "meta".');
-      } else {
-        if ('data' in doc && 'errors' in doc) {
-          errors.push('Top level keys "errors" and "data" cannot both be present in a JSON API document');
-        }
-      }
-      if ('data' in doc) {
-        if (!(doc.data === null || Array.isArray(doc.data) || typeof doc.data === 'object')) {
-          errors.push('data must be null, an object, or an array');
-        }
-      }
-      if ('meta' in doc) {
-        if (typeof doc.meta !== 'object') {
-          errors.push('meta must be an object');
-        }
-      }
-      if ('errors' in doc) {
-        if (!Array.isArray(doc.errors)) {
-          errors.push('errors must be an array');
-        }
-      }
-      if ('links' in doc) {
-        if (typeof doc.links !== 'object') {
-          errors.push('links must be an object');
-        }
-      }
-      if ('jsonapi' in doc) {
-        if (typeof doc.jsonapi !== 'object') {
-          errors.push('jsonapi must be an object');
-        }
-      }
-      if ('included' in doc) {
-        if (typeof doc.included !== 'object') {
-          errors.push('included must be an array');
-        }
-      }
-    }
-    assert(`Response must be normalized to a valid JSON API document:\n\t* ${errors.join('\n\t* ')}`, errors.length === 0);
-  }
-}
-function normalizeResponseHelper(serializer, store, modelClass, payload, id, requestType) {
-  let normalizedResponse = serializer ? serializer.normalizeResponse(store, modelClass, payload, id, requestType) : payload;
-  validateDocumentStructure(normalizedResponse);
-  return normalizedResponse;
-}
 const Touching = Symbol('touching');
 const RequestPromise = Symbol('promise');
 function hasRecordIdentifier(op) {
   return 'recordIdentifier' in op;
 }
 class RequestCache {
-  constructor() {
+  constructor(store) {
     this._pending = Object.create(null);
     this._done = new Map();
     this._subscriptions = Object.create(null);
+    this._toFlush = [];
+    this._store = void 0;
+    this._store = store;
+  }
+  _clearEntries(identifier) {
+    this._done.delete(identifier);
   }
   enqueue(promise, queryRequest) {
     let query = queryRequest.data[0];
@@ -4753,7 +4588,7 @@ class RequestCache {
       request[RequestPromise] = promise;
       this._pending[lid].push(request);
       this._triggerSubscriptions(request);
-      promise.then(result => {
+      return promise.then(result => {
         this._dequeue(lid, request);
         let finalizedRequest = {
           state: 'fulfilled',
@@ -4766,6 +4601,7 @@ class RequestCache {
         finalizedRequest[Touching] = request[Touching];
         this._addDone(finalizedRequest);
         this._triggerSubscriptions(finalizedRequest);
+        return result;
       }, error => {
         this._dequeue(lid, request);
         let finalizedRequest = {
@@ -4779,10 +4615,30 @@ class RequestCache {
         finalizedRequest[Touching] = request[Touching];
         this._addDone(finalizedRequest);
         this._triggerSubscriptions(finalizedRequest);
+        throw error;
       });
     }
+    assert(`Expected a well formed  query`);
   }
   _triggerSubscriptions(req) {
+    if (req.state === 'pending') {
+      this._flushRequest(req);
+      return;
+    }
+    this._toFlush.push(req);
+    if (this._toFlush.length === 1) {
+      this._store.notifications._onNextFlush(() => {
+        this._flush();
+      });
+    }
+  }
+  _flush() {
+    this._toFlush.forEach(req => {
+      this._flushRequest(req);
+    });
+    this._toFlush = [];
+  }
+  _flushRequest(req) {
     req[Touching].forEach(identifier => {
       if (this._subscriptions[identifier.lid]) {
         this._subscriptions[identifier.lid].forEach(callback => callback(req));
@@ -4823,636 +4679,16 @@ class RequestCache {
   getPendingRequestsForRecord(identifier) {
     if (this._pending[identifier.lid]) {
       return this._pending[identifier.lid];
-    }
-    return [];
-  }
-  getLastRequestForRecord(identifier) {
-    let requests = this._done.get(identifier);
-    if (requests) {
-      return requests[requests.length - 1];
-    }
-    return null;
-  }
-}
-
-/**
- * @module @ember-data/store
- */
-function payloadIsNotBlank$1(adapterPayload) {
-  if (Array.isArray(adapterPayload)) {
-    return true;
-  } else {
-    return Object.keys(adapterPayload || {}).length !== 0;
-  }
-}
-const SaveOp = Symbol('SaveOp');
-/**
- * Manages the state of network requests initiated by the store
- *
- * @class FetchManager
- * @private
- */
-class FetchManager {
-  // saves which are pending in the runloop
-
-  // fetches pending in the runloop, waiting to be coalesced
-
-  constructor(store) {
-    this._store = store;
-    // used to keep track of all the find requests that need to be coalesced
-    this._pendingFetch = new Map();
-    this._pendingSave = [];
-    this.requestCache = new RequestCache();
-    this.isDestroyed = false;
-  }
-  clearEntries(identifier) {
-    this.requestCache._done.delete(identifier);
-  }
-
-  /**
-    This method is called by `record.save`, and gets passed a
-    resolver for the promise that `record.save` returns.
-     It schedules saving to happen at the end of the run loop.
-     @internal
-  */
-  scheduleSave(identifier, options) {
-    let promiseLabel = 'DS: Model#save ' + this;
-    let resolver = RSVP.defer(promiseLabel);
-    let query = {
-      op: 'saveRecord',
-      recordIdentifier: identifier,
-      options
-    };
-    let queryRequest = {
-      data: [query]
-    };
-    let snapshot = new Snapshot(options, identifier, this._store);
-    let pendingSaveItem = {
-      snapshot: snapshot,
-      resolver: resolver,
-      identifier,
-      options,
-      queryRequest
-    };
-    this._pendingSave.push(pendingSaveItem);
-    _backburner.scheduleOnce('actions', this, this._flushPendingSaves);
-    this.requestCache.enqueue(resolver.promise, pendingSaveItem.queryRequest);
-    return resolver.promise;
-  }
-
-  /**
-    This method is called at the end of the run loop, and
-    flushes any records passed into `scheduleSave`
-     @method flushPendingSave
-    @internal
-  */
-  _flushPendingSaves() {
-    const store = this._store;
-    let pending = this._pendingSave.slice();
-    this._pendingSave = [];
-    for (let i = 0, j = pending.length; i < j; i++) {
-      let pendingItem = pending[i];
-      _flushPendingSave(store, pendingItem);
-    }
-  }
-  scheduleFetch(identifier, options) {
-    // TODO Probably the store should pass in the query object
-    let shouldTrace = isDevelopingApp() && this._store.generateStackTracesForTrackedRequests;
-    let query = {
-      op: 'findRecord',
-      recordIdentifier: identifier,
-      options
-    };
-    let queryRequest = {
-      data: [query]
-    };
-    let pendingFetch = this.getPendingFetch(identifier, options);
-    if (pendingFetch) {
-      return pendingFetch;
-    }
-    let id = identifier.id;
-    let modelName = identifier.type;
-    let resolver = RSVP.defer(`Fetching ${modelName}' with id: ${id}`);
-    let pendingFetchItem = {
-      identifier,
-      resolver,
-      options,
-      queryRequest
-    };
-    if (macroCondition(isDevelopingApp())) {
-      if (shouldTrace) {
-        let trace;
-        try {
-          throw new Error(`Trace Origin for scheduled fetch for ${modelName}:${id}.`);
-        } catch (e) {
-          trace = e;
-        }
-
-        // enable folks to discover the origin of this findRecord call when
-        // debugging. Ideally we would have a tracked queue for requests with
-        // labels or local IDs that could be used to merge this trace with
-        // the trace made available when we detect an async leak
-        pendingFetchItem.trace = trace;
-      }
-    }
-    let resolverPromise = resolver.promise;
-    const store = this._store;
-    const isLoading = !store._instanceCache.recordIsLoaded(identifier); // we don't use isLoading directly because we are the request
-
-    const promise = resolverPromise.then(payload => {
-      // ensure that regardless of id returned we assign to the correct record
-      if (payload.data && !Array.isArray(payload.data)) {
-        payload.data.lid = identifier.lid;
-      }
-
-      // additional data received in the payload
-      // may result in the merging of identifiers (and thus records)
-      let potentiallyNewIm = store._push(payload);
-      if (potentiallyNewIm && !Array.isArray(potentiallyNewIm)) {
-        return potentiallyNewIm;
-      }
-      return identifier;
-    }, error => {
-      const recordData = store._instanceCache.peek({
-        identifier,
-        bucket: 'recordData'
-      });
-      if (!recordData || recordData.isEmpty(identifier) || isLoading) {
-        let isReleasable = true;
-        if (macroCondition(dependencySatisfies("@ember-data/graph", "*"))) {
-          if (!recordData) {
-            const graphFor = importSync('@ember-data/graph/-private').graphFor;
-            const graph = graphFor(store);
-            isReleasable = graph.isReleasable(identifier);
-            if (!isReleasable) {
-              graph.unload(identifier, true);
-            }
-          }
-        }
-        if (recordData || isReleasable) {
-          store._instanceCache.unloadRecord(identifier);
-        }
-      }
-      throw error;
-    });
-    if (this._pendingFetch.size === 0) {
-      _backburner.schedule('actions', this, this.flushAllPendingFetches);
-    }
-    let fetches = this._pendingFetch;
-    if (!fetches.has(modelName)) {
-      fetches.set(modelName, []);
-    }
-    fetches.get(modelName).push(pendingFetchItem);
-    pendingFetchItem.promise = promise;
-    this.requestCache.enqueue(resolverPromise, pendingFetchItem.queryRequest);
-    return promise;
-  }
-  getPendingFetch(identifier, options) {
-    let pendingFetches = this._pendingFetch.get(identifier.type);
-
-    // We already have a pending fetch for this
-    if (pendingFetches) {
-      let matchingPendingFetch = pendingFetches.find(fetch => fetch.identifier === identifier && isSameRequest(options, fetch.options));
-      if (matchingPendingFetch) {
-        return matchingPendingFetch.promise;
-      }
-    }
-  }
-  flushAllPendingFetches() {
-    if (this.isDestroyed) {
-      return;
-    }
-    const store = this._store;
-    this._pendingFetch.forEach((fetchItem, type) => _flushPendingFetchForType(store, fetchItem, type));
-    this._pendingFetch.clear();
-  }
-  destroy() {
-    this.isDestroyed = true;
-  }
-}
-
-// this function helps resolve whether we have a pending request that we should use instead
-function isSameRequest(options = {}, existingOptions = {}) {
-  let includedMatches = !options.include || options.include === existingOptions.include;
-  let adapterOptionsMatches = options.adapterOptions === existingOptions.adapterOptions;
-  return includedMatches && adapterOptionsMatches;
-}
-function _findMany(store, adapter, modelName, snapshots) {
-  let modelClass = store.modelFor(modelName); // `adapter.findMany` gets the modelClass still
-  const ids = snapshots.map(s => s.id);
-  assert(`Cannot fetch a record without an id`, ids.every(v => v !== null));
-  assert(`Expected this adapter to implement findMany for coalescing`, adapter.findMany);
-  let promise = adapter.findMany(store, modelClass, ids, snapshots);
-  let label = `DS: Handle Adapter#findMany of '${modelName}'`;
-  if (promise === undefined) {
-    throw new Error('adapter.findMany returned undefined, this was very likely a mistake');
-  }
-  promise = guardDestroyedStore(promise, store, label);
-  return promise.then(adapterPayload => {
-    assert(`You made a 'findMany' request for '${modelName}' records with ids '[${ids}]', but the adapter's response did not have any data`, !!payloadIsNotBlank$1(adapterPayload));
-    let serializer = store.serializerFor(modelName);
-    let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findMany');
-    return payload;
-  });
-}
-function rejectFetchedItems(fetchMap, snapshots, error) {
-  for (let i = 0, l = snapshots.length; i < l; i++) {
-    let snapshot = snapshots[i];
-    let pair = fetchMap.get(snapshot);
-    if (pair) {
-      pair.resolver.reject(error || new Error(`Expected: '<${snapshot.modelName}:${snapshot.id}>' to be present in the adapter provided payload, but it was not found.`));
-    }
-  }
-}
-function handleFoundRecords(store, fetchMap, snapshots, coalescedPayload) {
-  /*
-    It is possible that the same ID is included multiple times
-    via multiple snapshots. This happens when more than one
-    options hash was supplied, each of which must be uniquely
-    accounted for.
-     However, since we can't map from response to a specific
-    options object, we resolve all snapshots by id with
-    the first response we see.
-  */
-  let snapshotsById = new Map();
-  for (let i = 0; i < snapshots.length; i++) {
-    let id = snapshots[i].id;
-    let snapshotGroup = snapshotsById.get(id);
-    if (!snapshotGroup) {
-      snapshotGroup = [];
-      snapshotsById.set(id, snapshotGroup);
-    }
-    snapshotGroup.push(snapshots[i]);
-  }
-  const included = Array.isArray(coalescedPayload.included) ? coalescedPayload.included : [];
-
-  // resolve found records
-  let resources = coalescedPayload.data;
-  for (let i = 0, l = resources.length; i < l; i++) {
-    let resource = resources[i];
-    let snapshotGroup = snapshotsById.get(resource.id);
-    snapshotsById.delete(resource.id);
-    if (!snapshotGroup) {
-      // TODO consider whether this should be a deprecation/assertion
-      included.push(resource);
-    } else {
-      snapshotGroup.forEach(snapshot => {
-        let pair = fetchMap.get(snapshot);
-        let resolver = pair.resolver;
-        resolver.resolve({
-          data: resource
-        });
-      });
-    }
-  }
-  if (included.length > 0) {
-    store._push({
-      data: null,
-      included
-    });
-  }
-  if (snapshotsById.size === 0) {
-    return;
-  }
-
-  // reject missing records
-  let rejected = [];
-  snapshotsById.forEach(snapshots => {
-    rejected.push(...snapshots);
-  });
-  warn('Ember Data expected to find records with the following ids in the adapter response from findMany but they were missing: [ "' + [...snapshotsById.values()].map(r => r[0].id).join('", "') + '" ]', {
-    id: 'ds.store.missing-records-from-adapter'
-  });
-  rejectFetchedItems(fetchMap, rejected);
-}
-function _fetchRecord(store, fetchItem) {
-  let identifier = fetchItem.identifier;
-  let modelName = identifier.type;
-  let adapter = store.adapterFor(modelName);
-  assert(`You tried to find a record but you have no adapter (for ${modelName})`, adapter);
-  assert(`You tried to find a record but your adapter (for ${modelName}) does not implement 'findRecord'`, typeof adapter.findRecord === 'function');
-  let snapshot = new Snapshot(fetchItem.options, identifier, store);
-  let klass = store.modelFor(identifier.type);
-  let id = identifier.id;
-  let label = `DS: Handle Adapter#findRecord of '${modelName}' with id: '${id}'`;
-  let promise = guardDestroyedStore(resolve().then(() => {
-    return adapter.findRecord(store, klass, identifier.id, snapshot);
-  }), store, label).then(adapterPayload => {
-    assert(`You made a 'findRecord' request for a '${modelName}' with id '${id}', but the adapter's response did not have any data`, !!payloadIsNotBlank$1(adapterPayload));
-    let serializer = store.serializerFor(modelName);
-    let payload = normalizeResponseHelper(serializer, store, klass, adapterPayload, id, 'findRecord');
-    assert(`Ember Data expected the primary data returned from a 'findRecord' response to be an object but instead it found an array.`, !Array.isArray(payload.data));
-    assert(`The 'findRecord' request for ${modelName}:${id} resolved indicating success but contained no primary data. To indicate a 404 not found you should either reject the promise returned by the adapter's findRecord method or throw a NotFoundError.`, 'data' in payload && payload.data !== null && typeof payload.data === 'object');
-    warn(`You requested a record of type '${modelName}' with id '${id}' but the adapter returned a payload with primary data having an id of '${payload.data.id}'. Use 'store.findRecord()' when the requested id is the same as the one returned by the adapter. In other cases use 'store.queryRecord()' instead.`, coerceId(payload.data.id) === coerceId(id), {
-      id: 'ds.store.findRecord.id-mismatch'
-    });
-    return payload;
-  });
-  fetchItem.resolver.resolve(promise);
-}
-function _processCoalescedGroup(store, fetchMap, group, adapter, modelName) {
-  if (group.length > 1) {
-    _findMany(store, adapter, modelName, group).then(payloads => {
-      handleFoundRecords(store, fetchMap, group, payloads);
-    }).catch(error => {
-      rejectFetchedItems(fetchMap, group, error);
-    });
-  } else if (group.length === 1) {
-    _fetchRecord(store, fetchMap.get(group[0]));
-  } else {
-    assert("You cannot return an empty array from adapter's method groupRecordsForFindMany", false);
-  }
-}
-function _flushPendingFetchForType(store, pendingFetchItems, modelName) {
-  let adapter = store.adapterFor(modelName);
-  let shouldCoalesce = !!adapter.findMany && adapter.coalesceFindRequests;
-  let totalItems = pendingFetchItems.length;
-  if (shouldCoalesce) {
-    let snapshots = new Array(totalItems);
-    let fetchMap = new Map();
-    for (let i = 0; i < totalItems; i++) {
-      let fetchItem = pendingFetchItems[i];
-      snapshots[i] = new Snapshot(fetchItem.options, fetchItem.identifier, store);
-      fetchMap.set(snapshots[i], fetchItem);
-    }
-    let groups;
-    if (adapter.groupRecordsForFindMany) {
-      groups = adapter.groupRecordsForFindMany(store, snapshots);
-    } else {
-      groups = [snapshots];
-    }
-    for (let i = 0, l = groups.length; i < l; i++) {
-      _processCoalescedGroup(store, fetchMap, groups[i], adapter, modelName);
-    }
-  } else {
-    for (let i = 0; i < totalItems; i++) {
-      _fetchRecord(store, pendingFetchItems[i]);
-    }
-  }
-}
-function _flushPendingSave(store, pending) {
-  const {
-    snapshot,
-    resolver,
-    identifier,
-    options
-  } = pending;
-  const adapter = store.adapterFor(identifier.type);
-  const operation = options[SaveOp];
-  let modelName = snapshot.modelName;
-  let modelClass = store.modelFor(modelName);
-  const record = store._instanceCache.getRecord(identifier);
-  assert(`You tried to update a record but you have no adapter (for ${modelName})`, adapter);
-  assert(`You tried to update a record but your adapter (for ${modelName}) does not implement '${operation}'`, typeof adapter[operation] === 'function');
-  let promise = resolve().then(() => adapter[operation](store, modelClass, snapshot));
-  let serializer = store.serializerFor(modelName);
-  let label = `DS: Extract and notify about ${operation} completion of ${identifier}`;
-  assert(`Your adapter's '${operation}' method must return a value, but it returned 'undefined'`, promise !== undefined);
-  promise = _guard(guardDestroyedStore(promise, store, label), _bind(_objectIsAlive, record)).then(adapterPayload => {
-    if (!_objectIsAlive(record)) {
-      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
-        deprecate(`A Promise while saving ${modelName} did not resolve by the time your model was destroyed. This will error in a future release.`, false, {
-          id: 'ember-data:rsvp-unresolved-async',
-          until: '5.0',
-          for: '@ember-data/store',
-          since: {
-            available: '4.5',
-            enabled: '4.5'
-          }
-        });
-      }
-    }
-    if (adapterPayload) {
-      return normalizeResponseHelper(serializer, store, modelClass, adapterPayload, snapshot.id, operation);
-    }
-  });
-  resolver.resolve(promise);
-}
-
-/**
-  SnapshotRecordArray is not directly instantiable.
-  Instances are provided to consuming application's
-  adapters for certain requests.
-
-  @class SnapshotRecordArray
-  @public
-*/
-class SnapshotRecordArray {
-  /**
-    SnapshotRecordArray is not directly instantiable.
-    Instances are provided to consuming application's
-    adapters and serializers for certain requests.
-     @method constructor
-    @private
-    @constructor
-    @param {RecordArray} recordArray
-    @param options
-   */
-  constructor(store, recordArray, options = {}) {
-    this.__store = store;
-    /**
-      An array of snapshots
-      @private
-      @property _snapshots
-      @type {Array}
-    */
-    this._snapshots = null;
-
-    /**
-      An array of records
-      @private
-      @property _recordArray
-      @type {Array}
-    */
-    this._recordArray = recordArray;
-
-    /**
-      Number of records in the array
-       Example
-       ```app/adapters/post.js
-      import JSONAPIAdapter from '@ember-data/adapter/json-api';
-       export default class PostAdapter extends JSONAPIAdapter {
-        shouldReloadAll(store, snapshotRecordArray) {
-          return !snapshotRecordArray.length;
-        }
-      });
-      ```
-       @property length
-      @public
-      @type {Number}
-    */
-    this.length = recordArray.length; // deal with computedProperty shennanigans
-
-    /**
-      A hash of adapter options passed into the store method for this request.
-       Example
-       ```app/adapters/post.js
-      import MyCustomAdapter from './custom-adapter';
-       export default class PostAdapter extends MyCustomAdapter {
-        findAll(store, type, sinceToken, snapshotRecordArray) {
-          if (snapshotRecordArray.adapterOptions.subscribe) {
-            // ...
-          }
-          // ...
-        }
-      }
-      ```
-       @property adapterOptions
-      @public
-      @type {Object}
-    */
-    this.adapterOptions = options.adapterOptions;
-
-    /**
-      The relationships to include for this request.
-       Example
-       ```app/adapters/application.js
-      import Adapter from '@ember-data/adapter';
-       export default class ApplicationAdapter extends Adapter {
-        findAll(store, type, snapshotRecordArray) {
-          let url = `/${type.modelName}?include=${encodeURIComponent(snapshotRecordArray.include)}`;
-           return fetch(url).then((response) => response.json())
-        }
-      }
-      ```
-       @property include
-      @public
-      @type {String|Array}
-    */
-    this.include = options.include;
-  }
-
-  /**
-    The type of the underlying records for the snapshots in the array, as a Model
-    @property type
-    @deprecated
-    @public
-    @type {Model}
-  */
-
-  /**
-    The modelName of the underlying records for the snapshots in the array, as a Model
-    @property modelName
-    @public
-    @type {Model}
-  */
-  get modelName() {
-    return this._recordArray.modelName;
-  }
-
-  /**
-    Get snapshots of the underlying record array
-     Example
-     ```app/adapters/post.js
-    import JSONAPIAdapter from '@ember-data/adapter/json-api';
-     export default class PostAdapter extends JSONAPIAdapter {
-      shouldReloadAll(store, snapshotArray) {
-        let snapshots = snapshotArray.snapshots();
-         return snapshots.any(function(ticketSnapshot) {
-          let timeDiff = moment().diff(ticketSnapshot.attr('lastAccessedAt'), 'minutes');
-          if (timeDiff > 20) {
-            return true;
-          } else {
-            return false;
-          }
-        });
-      }
-    }
-    ```
-     @method snapshots
-    @public
-    @return {Array} Array of snapshots
-  */
-  snapshots() {
-    if (this._snapshots !== null) {
-      return this._snapshots;
-    }
-    const {
-      _instanceCache
-    } = this.__store;
-    this._snapshots = this._recordArray[SOURCE].map(identifier => _instanceCache.createSnapshot(identifier));
-    return this._snapshots;
-  }
-}
-if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SNAPSHOT_MODEL_CLASS_ACCESS)) {
-  Object.defineProperty(SnapshotRecordArray.prototype, 'type', {
-    get() {
-      deprecate(`Using SnapshotRecordArray.type to access the ModelClass for a record is deprecated. Use store.modelFor(<modelName>) instead.`, false, {
-        id: 'ember-data:deprecate-snapshot-model-class-access',
-        until: '5.0',
-        for: 'ember-data',
-        since: {
-          available: '4.5.0',
-          enabled: '4.5.0'
-        }
-      });
-      return this._recordArray.type;
-    }
-  });
-}
-
-/**
-  @module @ember-data/store
-*/
-
-function payloadIsNotBlank(adapterPayload) {
-  if (Array.isArray(adapterPayload)) {
-    return true;
-  } else {
-    return Object.keys(adapterPayload || {}).length;
+    }
+    return [];
+  }
+  getLastRequestForRecord(identifier) {
+    let requests = this._done.get(identifier);
+    if (requests) {
+      return requests[requests.length - 1];
+    }
+    return null;
   }
-}
-function _findAll(adapter, store, modelName, options, snapshotArray) {
-  let modelClass = store.modelFor(modelName); // adapter.findAll depends on the class
-  let recordArray = store.peekAll(modelName);
-  snapshotArray = snapshotArray || new SnapshotRecordArray(store, recordArray, options);
-  let promise = Promise$1.resolve().then(() => adapter.findAll(store, modelClass, null, snapshotArray));
-  let label = 'DS: Handle Adapter#findAll of ' + modelClass;
-  promise = guardDestroyedStore(promise, store, label);
-  return promise.then(adapterPayload => {
-    assert(`You made a 'findAll' request for '${modelName}' records, but the adapter's response did not have any data`, payloadIsNotBlank(adapterPayload));
-    let serializer = store.serializerFor(modelName);
-    let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findAll');
-    store._push(payload);
-    recordArray.isUpdating = false;
-    return recordArray;
-  }, null, 'DS: Extract payload of findAll ${modelName}');
-}
-function _query(adapter, store, modelName, query, recordArray, options) {
-  let modelClass = store.modelFor(modelName); // adapter.query needs the class
-
-  // TODO @deprecate RecordArrays being passed to Adapters
-  recordArray = recordArray || store.recordArrayManager.createArray({
-    type: modelName,
-    query
-  });
-  let promise = Promise$1.resolve().then(() => adapter.query(store, modelClass, query, recordArray, options));
-  let label = `DS: Handle Adapter#query of ${modelName}`;
-  promise = guardDestroyedStore(promise, store, label);
-  return promise.then(adapterPayload => {
-    let serializer = store.serializerFor(modelName);
-    let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'query');
-    let identifiers = store._push(payload);
-    assert('The response to store.query is expected to be an array but it was a single record. Please wrap your response in an array or use `store.queryRecord` to query for a single record.', Array.isArray(identifiers));
-    store.recordArrayManager.populateManagedArray(recordArray, identifiers, payload);
-    return recordArray;
-  }, null, `DS: Extract payload of query ${modelName}`);
-}
-function _queryRecord(adapter, store, modelName, query, options) {
-  let modelClass = store.modelFor(modelName); // adapter.queryRecord needs the class
-  let promise = Promise$1.resolve().then(() => adapter.queryRecord(store, modelClass, query, options));
-  let label = `DS: Handle Adapter#queryRecord of ${modelName}`;
-  promise = guardDestroyedStore(promise, store, label);
-  return promise.then(adapterPayload => {
-    let serializer = store.serializerFor(modelName);
-    let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'queryRecord');
-    assert(`Expected the primary data returned by the serializer for a 'queryRecord' response to be a single object or null but instead it was an array.`, !Array.isArray(payload.data));
-    return store._push(payload);
-  }, null, `DS: Extract payload of queryRecord ${modelName}`);
-}
-function promiseRecord(store, promise) {
-  let toReturn = promise.then(identifier => store.peekRecord(identifier));
-  return promiseObject(toReturn);
 }
 
 /**
@@ -5462,155 +4698,110 @@ function promiseRecord(store, promise) {
 // hello world
 
 let _Cache;
-function freeze(obj) {
-  if (typeof Object.freeze === 'function') {
-    return Object.freeze(obj);
-  }
-  return obj;
-}
-/**
-  The store contains all of the data for records loaded from the server.
-  It is also responsible for creating instances of `Model` that wrap
-  the individual data for a record, so that they can be bound to in your
-  Handlebars templates.
-
-  Define your application's store like this:
-
-  ```app/services/store.js
-  import Store from '@ember-data/store';
-
-  export default class MyStore extends Store {}
-  ```
-
-  Most Ember.js applications will only have a single `Store` that is
-  automatically created by their `Ember.Application`.
-
-  You can retrieve models from the store in several ways. To retrieve a record
-  for a specific id, use `Store`'s `findRecord()` method:
-
-  ```javascript
-  store.findRecord('person', 123).then(function (person) {
-  });
-  ```
-
-  By default, the store will talk to your backend using a standard
-  REST mechanism. You can customize how the store talks to your
-  backend by specifying a custom adapter:
-
-  ```app/adapters/application.js
-  import Adapter from '@ember-data/adapter';
-
-  export default class ApplicationAdapter extends Adapter {
-  }
-  ```
-
-  You can learn more about writing a custom adapter by reading the `Adapter`
-  documentation.
-
-  ### Store createRecord() vs. push() vs. pushPayload()
-
-  The store provides multiple ways to create new record objects. They have
-  some subtle differences in their use which are detailed below:
+class Store {
+  /**
+   * Provides access to the NotificationManager associated
+   * with this Store instance.
+   *
+   * The NotificationManager can be used to subscribe to
+   * changes to the cache.
+   *
+   * @property {NotificationManager} notifications
+   * @public
+   */
 
-  [createRecord](../methods/createRecord?anchor=createRecord) is used for creating new
-  records on the client side. This will return a new record in the
-  `created.uncommitted` state. In order to persist this record to the
-  backend, you will need to call `record.save()`.
+  /**
+   * Provides access to the IdentifierCache instance
+   * for this store.
+   *
+   * The IdentifierCache can be used to generate or
+   * retrieve a stable unique identifier for any resource.
+   *
+   * @property {IdentifierCache} identifierCache
+   * @public
+   */
 
-  [push](../methods/push?anchor=push) is used to notify Ember Data's store of new or
-  updated records that exist in the backend. This will return a record
-  in the `loaded.saved` state. The primary use-case for `store#push` is
-  to notify Ember Data about record updates (full or partial) that happen
-  outside of the normal adapter methods (for example
-  [SSE](http://dev.w3.org/html5/eventsource/) or [Web
-  Sockets](http://www.w3.org/TR/2009/WD-websockets-20091222/)).
+  /**
+   * Provides access to the requestManager instance associated
+   * with this Store instance.
+   *
+   * When using `ember-data` this property is automatically
+   * set to an instance of `RequestManager`. When not using `ember-data`
+   * you must configure this property yourself, either by declaring
+   * it as a service or by initializing it.
+   *
+   * ```ts
+   * import Store, { CacheHandler } from '@ember-data/store';
+   * import RequestManager from '@ember-data/request';
+   * import Fetch from '@ember/data/request/fetch';
+   *
+   * class extends Store {
+   *   constructor() {
+   *     super(...arguments);
+   *     this.requestManager = new RequestManager();
+   *     this.requestManager.use([Fetch]);
+   *     this.requestManager.useCache(CacheHandler);
+   *   }
+   * }
+   * ```
+   *
+   * @public
+   * @property {RequestManager} requestManager
+   */
 
-  [pushPayload](../methods/pushPayload?anchor=pushPayload) is a convenience wrapper for
-  `store#push` that will deserialize payloads if the
-  Serializer implements a `pushPayload` method.
+  /**
+   * A Property which an App may set to provide a Lifetimes Service
+   * to control when a cached request becomes stale.
+   *
+   * Note, when defined, these methods will only be invoked if `key` `url` and `method`
+   * are all present.
+   *
+   * `isSoftExpired` will only be invoked if `isHardExpired` returns `false`.
+   *
+   * ```ts
+   * store.lifetimes = {
+   *   // make the request and ignore the current cache state
+   *   isHardExpired(key: string, url: string, method?: HTTPMethod): boolean {
+   *     return false;
+   *   }
+   *
+   *   // make the request in the background if true, return cache state
+   *   isSoftExpired(key: string, url: string, method: HTTPMethod): boolean {
+   *     return false;
+   *   }
+   * }
+   * ```
+   *
+   * @public
+   * @property {LivetimesService|undefined} lifetimes
+   */
 
-  Note: When creating a new record using any of the above methods
-  Ember Data will update `RecordArray`s such as those returned by
-  `store#peekAll()` or `store#findAll()`. This means any
-  data bindings or computed properties that depend on the RecordArray
-  will automatically be synced to include the new or updated record
-  values.
+  // Private
 
-  @main @ember-data/store
-  @class Store
-  @public
-  @extends Ember.Service
-*/
+  // DEBUG-only properties
 
-class Store {
   /**
     @method init
     @private
   */
   constructor(createArgs) {
-    this.__private_singleton_recordData = void 0;
     this.isDestroying = false;
     this.isDestroyed = false;
     Object.assign(this, createArgs);
-
-    /**
-     * Provides access to the IdentifierCache instance
-     * for this store.
-     *
-     * The IdentifierCache can be used to generate or
-     * retrieve a stable unique identifier for any resource.
-     *
-     * @property {IdentifierCache} identifierCache
-     * @public
-     */
     this.identifierCache = new IdentifierCache();
+    this.notifications = new NotificationManager(this);
 
     // private but maybe useful to be here, somewhat intimate
     this.recordArrayManager = new RecordArrayManager({
       store: this
     });
-    this.notifications = new NotificationManager(this);
 
     // private
-    this._fetchManager = new FetchManager(this);
+    this._requestCache = new RequestCache(this);
     this._instanceCache = new InstanceCache(this);
     this._adapterCache = Object.create(null);
     this._serializerCache = Object.create(null);
     this._modelFactoryCache = Object.create(null);
-    if (macroCondition(isDevelopingApp())) {
-      if (this.generateStackTracesForTrackedRequests === undefined) {
-        this.generateStackTracesForTrackedRequests = false;
-      }
-      this._trackedAsyncRequests = [];
-      this._trackAsyncRequestStart = label => {
-        let trace = 'set `store.generateStackTracesForTrackedRequests = true;` to get a detailed trace for where this request originated';
-        if (this.generateStackTracesForTrackedRequests) {
-          try {
-            throw new Error(`EmberData TrackedRequest: ${label}`);
-          } catch (e) {
-            trace = e;
-          }
-        }
-        let token = freeze({
-          label,
-          trace
-        });
-        this._trackedAsyncRequests.push(token);
-        return token;
-      };
-      this._trackAsyncRequestEnd = token => {
-        let index = this._trackedAsyncRequests.indexOf(token);
-        if (index === -1) {
-          throw new Error(`Attempted to end tracking for the following request but it was not being tracked:\n${token}`);
-        }
-        this._trackedAsyncRequests.splice(index, 1);
-      };
-      this.__asyncWaiter = () => {
-        let tracked = this._trackedAsyncRequests;
-        return this.DISABLE_WAITER || tracked.length === 0;
-      };
-      registerWaiter(this.__asyncWaiter);
-    }
   }
   _run(cb) {
     assert(`EmberData should never encounter a nested run`, !this._cbs);
@@ -5652,7 +4843,81 @@ class Store {
    * @public
    */
   getRequestStateService() {
-    return this._fetchManager.requestCache;
+    return this._requestCache;
+  }
+  _getAllPending() {
+    if (macroCondition(getOwnConfig().env.TESTING)) {
+      const all = [];
+      const pending = this._requestCache._pending;
+      const lids = Object.keys(pending);
+      lids.forEach(lid => {
+        all.push(...pending[lid].map(v => v[RequestPromise]));
+      });
+      const promise = Promise.allSettled(all);
+      promise.length = all.length;
+      return promise;
+    }
+  }
+
+  /**
+   * Issue a request via the configured RequestManager,
+   * inserting the response into the cache and handing
+   * back a Future which resolves to a ResponseDocument
+   *
+   * Resource data is always updated in the cache.
+   *
+   * Only GET requests have the request result and document
+   * cached by default when a cache key is present.
+   *
+   * The cache key used is `requestConfig.cacheOptions.key`
+   * if present, falling back to `requestconfig.url`.
+   *
+   * Params are not serialized as part of the cache-key, so
+   * either ensure they are already in the url or utilize
+   * `requestConfig.cacheOptions.key`. For queries issued
+   * via the `POST` method `requestConfig.cacheOptions.key`
+   * MUST be supplied for the document to be cached.
+   *
+   * @method request
+   * @param {StoreRequestInfo} requestConfig
+   * @returns {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 = {
+      store: this
+    };
+    if (macroCondition(getOwnConfig().env.TESTING)) {
+      if (this.DISABLE_WAITER) {
+        opts.disableTestWaiter = typeof requestConfig.disableTestWaiter === 'boolean' ? requestConfig.disableTestWaiter : true;
+      }
+    }
+    if (macroCondition(getOwnConfig().debug.LOG_REQUESTS)) {
+      let options;
+      try {
+        options = JSON.parse(JSON.stringify(requestConfig));
+      } catch {
+        options = requestConfig;
+      }
+      // eslint-disable-next-line no-console
+      console.log(`request: [[START]] ${requestConfig.op && !requestConfig.url ? '(LEGACY) ' : ''}${requestConfig.op || '<unknown operation>'} ${requestConfig.url || '<empty url>'}  ${requestConfig.method || '<empty method>'}`, options);
+    }
+    const future = this.requestManager.request(Object.assign(requestConfig, opts));
+    future.onFinalize(() => {
+      if (macroCondition(getOwnConfig().debug.LOG_REQUESTS)) {
+        // eslint-disable-next-line no-console
+        console.log(`request: [[FINALIZE]] ${requestConfig.op && !requestConfig.url ? '(LEGACY) ' : ''}${requestConfig.op || '<unknown operation>'} ${requestConfig.url || '<empty url>'}  ${requestConfig.method || '<empty method>'}`);
+      }
+      // skip flush for legacy belongsTo
+      if (requestConfig.op === 'findBelongsTo' && !requestConfig.url) {
+        return;
+      }
+      this.notifications._flush();
+    });
+    return future;
   }
 
   /**
@@ -5667,22 +4932,22 @@ class Store {
    * @method instantiateRecord (hook)
    * @param identifier
    * @param createRecordArgs
-   * @param recordDataFor
-   * @param notificationManager
+   * @param recordDataFor deprecated use this.cache
+   * @param notificationManager deprecated use this.notifications
    * @returns A record instance
    * @public
    */
-  instantiateRecord(identifier, createRecordArgs, recordDataFor, notificationManager) {
-    if (macroCondition(dependencySatisfies("@ember-data/model", "*"))) {
+  instantiateRecord(identifier, createRecordArgs) {
+    if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
       let modelName = identifier.type;
-      let recordData = this._instanceCache.getRecordData(identifier);
+      const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._instanceCache.getResourceCache(identifier) : this.cache;
       // TODO deprecate allowing unknown args setting
       let createOptions = {
         _createProps: createRecordArgs,
         // TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
         _secretInit: {
           identifier,
-          recordData,
+          cache,
           store: this,
           cb: secretInit
         }
@@ -5706,7 +4971,7 @@ class Store {
    * @param record
    */
   teardownRecord(record) {
-    if (macroCondition(dependencySatisfies("@ember-data/model", "*"))) {
+    if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
       assert(`expected to receive an instance of DSModel. If using a custom model make sure you implement teardownRecord`, 'destroy' in record);
       record.destroy();
     } else {
@@ -5725,7 +4990,7 @@ class Store {
    * @public
    */
   getSchemaDefinitionService() {
-    if (macroCondition(dependencySatisfies("@ember-data/model", "*"))) {
+    if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
       if (!this._schemaDefinitionService) {
         // it is potentially a mistake for the RFC to have not enabled chaining these services, though highlander rule is nice.
         // what ember-m3 did via private API to allow both worlds to interop would be much much harder using this.
@@ -5812,12 +5077,12 @@ class Store {
   // TODO @deprecate in favor of schema APIs, requires adapter/serializer overhaul or replacement
 
   modelFor(modelName) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyedStoreOnly(this, 'modelFor');
     }
     assert(`You need to pass a model name to the store's modelFor method`, modelName);
     assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
-    if (macroCondition(dependencySatisfies("@ember-data/model", "*"))) {
+    if (macroCondition(getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
       let normalizedModelName = normalizeModelName$1(modelName);
       let maybeFactory = getModelFactory(this, this._modelFactoryCache, normalizedModelName);
 
@@ -5860,7 +5125,7 @@ class Store {
     @return {Model} record
   */
   createRecord(modelName, inputProperties) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'createRecord');
     }
     assert(`You need to pass a model name to the store's createRecord method`, modelName);
@@ -5904,10 +5169,9 @@ class Store {
           assert(`The id ${properties.id} has already been used with another '${normalizedModelName}' record.`, !identifier);
         }
         const identifier = this.identifierCache.createIdentifierForNewRecord(resource);
-        const recordData = this._instanceCache.getRecordData(identifier);
-        const createOptions = normalizeProperties(this, identifier, properties, recordData.managedVersion === '1');
-        const resultProps = recordData.clientDidCreate(identifier, createOptions);
-        this.recordArrayManager.identifierAdded(identifier);
+        const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._instanceCache.getResourceCache(identifier) : this.cache;
+        const createOptions = normalizeProperties(this, identifier, properties, cache.managedVersion === '1');
+        const resultProps = cache.clientDidCreate(identifier, createOptions);
         record = this._instanceCache.getRecord(identifier, resultProps);
       });
     });
@@ -5928,18 +5192,18 @@ class Store {
     @param {Model} record
   */
   deleteRecord(record) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'deleteRecord');
     }
     const identifier = peekRecordIdentifier(record);
-    const recordData = identifier && this._instanceCache.peek({
+    const cache = identifier && (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._instanceCache.peek({
       identifier,
-      bucket: 'recordData'
-    });
-    assert(`expected a recordData instance to exist for the record`, recordData);
+      bucket: 'resourceCache'
+    }) : this.cache);
+    assert(`expected a cache instance to exist for the record`, cache);
     this._join(() => {
-      recordData.setIsDeleted(identifier, true);
-      if (recordData.isNew(identifier)) {
+      cache.setIsDeleted(identifier, true);
+      if (cache.isNew(identifier)) {
         _backburner.join(() => {
           this._instanceCache.unloadRecord(identifier);
         });
@@ -5961,7 +5225,7 @@ class Store {
     @param {Model} record
   */
   unloadRecord(record) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'unloadRecord');
     }
     const identifier = peekRecordIdentifier(record);
@@ -5980,7 +5244,7 @@ class Store {
     @private
   */
   find(modelName, id, options) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'find');
     }
     // The default `model` hook in Route calls `find(modelName, id)`,
@@ -6290,7 +5554,7 @@ class Store {
   */
 
   findRecord(resource, id, options) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'findRecord');
     }
     assert(`You need to pass a modelName or resource identifier as the first argument to the store's findRecord method`, resource);
@@ -6303,45 +5567,33 @@ class Store {
       resource = constructResource(type, normalizedId);
     }
     const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);
-    let promise;
     options = options || {};
     if (options.preload) {
+      // force reload if we preload to ensure we don't resolve the promise
+      // until we are complete, else we will end up background-reloading
+      // even for initial load.
+      if (!this._instanceCache.recordIsLoaded(identifier)) {
+        options.reload = true;
+      }
       this._join(() => {
         preloadData(this, identifier, options.preload);
       });
     }
-
-    // if not loaded start loading
-    if (!this._instanceCache.recordIsLoaded(identifier)) {
-      promise = this._instanceCache._fetchDataIfNeededForIdentifier(identifier, options);
-
-      // Refetch if the reload option is passed
-    } else if (options.reload) {
-      assertIdentifierHasId(identifier);
-      promise = this._fetchManager.scheduleFetch(identifier, options);
-    } else {
-      let snapshot = null;
-      let adapter = this.adapterFor(identifier.type);
-
-      // Refetch the record if the adapter thinks the record is stale
-      if (typeof options.reload === 'undefined' && adapter.shouldReloadRecord && adapter.shouldReloadRecord(this, snapshot = this._instanceCache.createSnapshot(identifier, options))) {
-        assertIdentifierHasId(identifier);
-        promise = this._fetchManager.scheduleFetch(identifier, options);
-      } else {
-        // Trigger the background refetch if backgroundReload option is passed
-        if (options.backgroundReload !== false && (options.backgroundReload || !adapter.shouldBackgroundReloadRecord || adapter.shouldBackgroundReloadRecord(this, snapshot = snapshot || this._instanceCache.createSnapshot(identifier, options)))) {
-          assertIdentifierHasId(identifier);
-          this._fetchManager.scheduleFetch(identifier, options);
-        }
-
-        // Return the cached record
-        promise = resolve(identifier);
+    const promise = this.request({
+      op: 'findRecord',
+      data: {
+        record: identifier,
+        options
       }
-    }
+    });
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
-      return promiseRecord(this, promise);
+      return promiseObject(promise.then(document => {
+        return document.content;
+      }));
     }
-    return promise.then(identifier => this.peekRecord(identifier));
+    return promise.then(document => {
+      return document.content;
+    });
   }
 
   /**
@@ -6375,7 +5627,7 @@ class Store {
   */
   // TODO @deprecate getReference (and references generally)
   getReference(resource, id) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'getReference');
     }
     let resourceIdentifier;
@@ -6434,7 +5686,7 @@ class Store {
       // this is basically an "are we not empty" query.
       return isLoaded ? this._instanceCache.getRecord(stableIdentifier) : null;
     }
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'peekRecord');
     }
     assert(`You need to pass a model name to the store's peekRecord method`, identifier);
@@ -6479,7 +5731,7 @@ class Store {
         until: '5.0',
         for: 'ember-data'
       });
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         assertDestroyingStore(this, 'hasRecordForId');
       }
       assert(`You need to pass a model name to the store's hasRecordForId method`, modelName);
@@ -6534,26 +5786,24 @@ class Store {
     @return {Promise} promise
   */
   query(modelName, query, options) {
-    if (macroCondition(isDevelopingApp())) {
+    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 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');
-    let adapterOptionsWrapper = {};
-    if (options && options.adapterOptions) {
-      adapterOptionsWrapper.adapterOptions = options.adapterOptions;
-    }
-    let recordArray = options?._recordArray || null;
-    let normalizedModelName = normalizeModelName$1(modelName);
-    let adapter = this.adapterFor(normalizedModelName);
-    assert(`You tried to load a query but you have no adapter (for ${modelName})`, adapter);
-    assert(`You tried to load a query but your adapter does not implement 'query'`, typeof adapter.query === 'function');
-    let queryPromise = _query(adapter, this, normalizedModelName, query, recordArray, adapterOptionsWrapper);
+    const promise = this.request({
+      op: 'query',
+      data: {
+        type: normalizeModelName$1(modelName),
+        query,
+        options: options || {}
+      }
+    });
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
-      return promiseArray(queryPromise);
+      return promiseArray(promise.then(document => document.content));
     }
-    return queryPromise;
+    return promise.then(document => document.content);
   }
 
   /**
@@ -6638,25 +5888,24 @@ class Store {
     @return {Promise} promise which resolves with the found record or `null`
   */
   queryRecord(modelName, query, options) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'queryRecord');
     }
     assert(`You need to pass a model name to the store's queryRecord method`, modelName);
     assert(`You need to pass a query hash to the store's queryRecord method`, query);
     assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
-    let normalizedModelName = normalizeModelName$1(modelName);
-    let adapter = this.adapterFor(normalizedModelName);
-    let adapterOptionsWrapper = {};
-    if (options && options.adapterOptions) {
-      adapterOptionsWrapper.adapterOptions = options.adapterOptions;
-    }
-    assert(`You tried to make a query but you have no adapter (for ${normalizedModelName})`, adapter);
-    assert(`You tried to make a query but your adapter does not implement 'queryRecord'`, typeof adapter.queryRecord === 'function');
-    const promise = _queryRecord(adapter, this, normalizedModelName, query, adapterOptionsWrapper);
+    const promise = this.request({
+      op: 'queryRecord',
+      data: {
+        type: normalizeModelName$1(modelName),
+        query,
+        options: options || {}
+      }
+    });
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
-      return promiseObject(promise.then(identifier => identifier && this.peekRecord(identifier)));
+      return promiseObject(promise.then(document => document.content));
     }
-    return promise.then(identifier => identifier && this.peekRecord(identifier));
+    return promise.then(document => document.content);
   }
 
   /**
@@ -6811,42 +6060,22 @@ class Store {
     @return {Promise} promise
   */
   findAll(modelName, options = {}) {
-    if (macroCondition(isDevelopingApp())) {
+    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');
-    let normalizedModelName = normalizeModelName$1(modelName);
-    let array = this.peekAll(normalizedModelName);
-    let fetch;
-    let adapter = this.adapterFor(normalizedModelName);
-    assert(`You tried to load all records but you have no adapter (for ${normalizedModelName})`, adapter);
-    assert(`You tried to load all records but your adapter does not implement 'findAll'`, typeof adapter.findAll === 'function');
-    if (options.reload) {
-      array.isUpdating = true;
-      fetch = _findAll(adapter, this, normalizedModelName, options);
-    } else {
-      let snapshotArray = new SnapshotRecordArray(this, array, options);
-      if (options.reload !== false) {
-        if (adapter.shouldReloadAll && adapter.shouldReloadAll(this, snapshotArray) || !adapter.shouldReloadAll && snapshotArray.length === 0) {
-          array.isUpdating = true;
-          fetch = _findAll(adapter, this, modelName, options, snapshotArray);
-        }
-      }
-      if (!fetch) {
-        if (options.backgroundReload === false) {
-          fetch = resolve(array);
-        } else if (options.backgroundReload || !adapter.shouldBackgroundReloadAll || adapter.shouldBackgroundReloadAll(this, snapshotArray)) {
-          array.isUpdating = true;
-          _findAll(adapter, this, modelName, options, snapshotArray);
-        }
-        fetch = resolve(array);
+    const promise = this.request({
+      op: 'findAll',
+      data: {
+        type: normalizeModelName$1(modelName),
+        options: options || {}
       }
-    }
+    });
     if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
-      return promiseArray(fetch);
+      return promiseArray(promise.then(document => document.content));
     }
-    return fetch;
+    return promise.then(document => document.content);
   }
 
   /**
@@ -6870,7 +6099,7 @@ class Store {
     @return {RecordArray}
   */
   peekAll(modelName) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'peekAll');
     }
     assert(`You need to pass a model name to the store's peekAll method`, modelName);
@@ -6892,7 +6121,7 @@ class Store {
     @param {String} modelName
   */
   unloadAll(modelName) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyedStoreOnly(this, 'unloadAll');
     }
     assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, !modelName || typeof modelName === 'string');
@@ -6901,7 +6130,7 @@ class Store {
         // destroy the graph before unloadAll
         // since then we avoid churning relationships
         // during unload
-        if (macroCondition(dependencySatisfies("@ember-data/graph", "*"))) {
+        if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
           const peekGraph = importSync('@ember-data/graph/-private').peekGraph;
           let graph = peekGraph(this);
           if (graph) {
@@ -7050,10 +6279,10 @@ class Store {
   */
 
   push(data) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'push');
     }
-    let pushed = this._push(data);
+    let pushed = this._push(data, false);
     if (Array.isArray(pushed)) {
       let records = pushed.map(identifier => this._instanceCache.getRecord(identifier));
       return records;
@@ -7072,8 +6301,8 @@ class Store {
     @param {Object} jsonApiDoc
     @return {StableRecordIdentifier|Array<StableRecordIdentifier>} identifiers for the primary records that had data loaded
   */
-  _push(jsonApiDoc) {
-    if (macroCondition(isDevelopingApp())) {
+  _push(jsonApiDoc, asyncFlush) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, '_push');
     }
     if (macroCondition(getOwnConfig().debug.LOG_PAYLOADS)) {
@@ -7086,33 +6315,23 @@ class Store {
         console.log('EmberData | Payload - push', jsonApiDoc);
       }
     }
+    if (asyncFlush) {
+      this._enableAsyncFlush = true;
+    }
     let ret;
     this._join(() => {
-      let included = jsonApiDoc.included;
-      let i, length;
-      if (included) {
-        for (i = 0, length = included.length; i < length; i++) {
-          this._instanceCache.loadData(included[i]);
-        }
-      }
-      if (Array.isArray(jsonApiDoc.data)) {
-        length = jsonApiDoc.data.length;
-        let identifiers = new Array(length);
-        for (i = 0; i < length; i++) {
-          identifiers[i] = this._instanceCache.loadData(jsonApiDoc.data[i]);
-        }
-        ret = identifiers;
-        return;
-      }
-      if (jsonApiDoc.data === null) {
-        ret = null;
-        return;
+      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA)) {
+        ret = legacyCachePut(this, {
+          content: jsonApiDoc
+        });
+      } else {
+        ret = this.cache.put({
+          content: jsonApiDoc
+        });
       }
-      assert(`Expected an object in the 'data' property in a call to 'push' for ${jsonApiDoc.type}, but was ${typeof jsonApiDoc.data}`, typeof jsonApiDoc.data === 'object');
-      ret = this._instanceCache.loadData(jsonApiDoc.data);
-      return;
     });
-    return ret;
+    this._enableAsyncFlush = null;
+    return ret.data;
   }
 
   /**
@@ -7160,7 +6379,7 @@ class Store {
   */
   // TODO @runspired @deprecate pushPayload in favor of looking up the serializer
   pushPayload(modelName, inputPayload) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'pushPayload');
     }
     let serializer;
@@ -7182,7 +6401,14 @@ class Store {
   // TODO @runspired @deprecate records should implement their own serialization if desired
   serializeRecord(record, options) {
     // TODO we used to check if the record was destroyed here
-    return this._instanceCache.createSnapshot(recordIdentifierFor(record)).serialize(options);
+    if (macroCondition(getOwnConfig().packages.HAS_COMPAT_PACKAGE)) {
+      if (!this._fetchManager) {
+        const FetchManager = importSync('@ember-data/legacy-compat/-private').FetchManager;
+        this._fetchManager = new FetchManager(this);
+      }
+      return this._fetchManager.createSnapshot(recordIdentifierFor(record)).serialize(options);
+    }
+    assert(`Store.serializeRecord is only available when utilizing @ember-data/legacy-compat for legacy compatibility`);
   }
 
   /**
@@ -7195,23 +6421,26 @@ class Store {
    * @returns {Promise<RecordInstance>}
    */
   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);
-    let recordData = identifier && this._instanceCache.peek({
+    const cache = identifier && (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this._instanceCache.peek({
       identifier,
-      bucket: 'recordData'
-    });
-    if (!recordData) {
+      bucket: 'resourceCache'
+    }) : this.cache);
+    if (!cache) {
       // this commonly means we're disconnected
       // but just in case we reject here to prevent bad things.
-      return reject(`Record Is Disconnected`);
+      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}`, recordData && this._instanceCache.recordIsLoaded(identifier));
-    if (recordDataIsFullyDeleted(this._instanceCache, identifier)) {
-      return resolve(record);
+    assert(`Cannot initiate a save request for an unloaded record: ${identifier}`, cache && this._instanceCache.recordIsLoaded(identifier));
+    if (resourceIsFullyDeleted(this._instanceCache, identifier)) {
+      return Promise.resolve(record);
     }
-    recordData.willCommit(identifier);
+    cache.willCommit(identifier);
     if (isDSModel(record)) {
       record.errors.clear();
     }
@@ -7219,121 +6448,76 @@ class Store {
       options = {};
     }
     let operation = 'updateRecord';
-    if (recordData.isNew(identifier)) {
+    if (cache.isNew(identifier)) {
       operation = 'createRecord';
-    } else if (recordData.isDeleted(identifier)) {
+    } else if (cache.isDeleted(identifier)) {
       operation = 'deleteRecord';
     }
-    const saveOptions = Object.assign({
-      [SaveOp]: operation
-    }, options);
-    let fetchManagerPromise = this._fetchManager.scheduleSave(identifier, saveOptions);
-    return fetchManagerPromise.then(payload => {
-      if (macroCondition(getOwnConfig().debug.LOG_PAYLOADS)) {
-        try {
-          let data = payload ? JSON.parse(JSON.stringify(payload)) : payload;
-          // eslint-disable-next-line no-console
-          console.log(`EmberData | Payload - ${operation}`, data);
-        } catch (e) {
-          // eslint-disable-next-line no-console
-          console.log(`EmberData | Payload - ${operation}`, payload);
-        }
+    return this.request({
+      op: operation,
+      data: {
+        options,
+        record: identifier
       }
-      /*
-      // TODO @runspired re-evaluate the below claim now that
-      // the save request pipeline is more streamlined.
-       Note to future spelunkers hoping to optimize.
-      We rely on this `run` to create a run loop if needed
-      that `store._push` and `store.saveRecord` will both share.
-       We use `join` because it is often the case that we
-      have an outer run loop available still from the first
-      call to `store._push`;
-      */
-      this._join(() => {
-        if (macroCondition(isDevelopingApp())) {
-          assertDestroyingStore(this, 'saveRecord');
-        }
-        let data = payload && payload.data;
-        if (!data) {
-          assert(`Your ${identifier.type} record was saved to the server, but the response does not have an id and no id has been set client side. Records must have ids. Please update the server response to provide an id in the response or generate the id on the client side either before saving the record or while normalizing the response.`, identifier.id);
-        }
-        const cache = this.identifierCache;
-        let actualIdentifier = identifier;
-        if (operation !== 'deleteRecord' && data) {
-          actualIdentifier = cache.updateRecordIdentifier(identifier, data);
-        }
-
-        //We first make sure the primary data has been updated
-        const recordData = this._instanceCache.getRecordData(actualIdentifier);
-        recordData.didCommit(identifier, data);
-        if (operation === 'deleteRecord') {
-          this.recordArrayManager.identifierRemoved(actualIdentifier);
-        }
-        if (payload && payload.included) {
-          this._push({
-            data: null,
-            included: payload.included
-          });
-        }
-      });
-      return record;
-    }).catch(e => {
-      let err = e;
-      if (!e) {
-        err = new Error(`Unknown Error Occurred During Request`);
-      } else if (typeof e === 'string') {
-        err = new Error(e);
-      }
-      adapterDidInvalidate(this, identifier, err);
-      throw err;
-    });
+    }).then(document => document.content);
   }
 
   /**
    * Instantiation hook allowing applications or addons to configure the store
-   * to utilize a custom RecordData implementation.
+   * to utilize a custom Cache implementation.
    *
-   * @method createRecordDataFor (hook)
+   * 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 identifier
    * @param storeWrapper
+   * @returns {Cache}
    */
-  createRecordDataFor(identifier, storeWrapper) {
-    if (macroCondition(dependencySatisfies("@ember-data/json-api", "*"))) {
-      // we can't greedily use require as this causes
-      // a cycle we can't easily fix (or clearly pin point) at present.
-      //
-      // it can be reproduced in partner tests by running
-      // node ./scripts/packages-for-commit.js && pnpm test-external:ember-observer
+  createCache(storeWrapper) {
+    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
       if (_Cache === undefined) {
-        _Cache = importSync('@ember-data/json-api/-private').Cache;
+        _Cache = importSync('@ember-data/json-api').default;
       }
-      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_V1CACHE_STORE_APIS)) {
-        if (arguments.length === 4) {
-          deprecate(`Store.createRecordDataFor(<type>, <id>, <lid>, <storeWrapper>) has been deprecated in favor of Store.createRecordDataFor(<identifier>, <storeWrapper>)`, false, {
-            id: 'ember-data:deprecate-v1cache-store-apis',
-            for: 'ember-data',
-            until: '5.0',
-            since: {
-              enabled: '4.7',
-              available: '4.7'
-            }
-          });
-          identifier = this.identifierCache.getOrCreateRecordIdentifier({
-            type: arguments[0],
-            id: arguments[1],
-            lid: arguments[2]
-          });
-          storeWrapper = arguments[3];
-        }
+      return new _Cache(storeWrapper);
+    }
+    assert(`Expected store.createCache to be implemented but it wasn't`);
+  }
+
+  /**
+   * 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 SingletonCacheManager(cache);
       }
-      this.__private_singleton_recordData = this.__private_singleton_recordData || new _Cache(storeWrapper);
-      this.__private_singleton_recordData.createCache(identifier);
-      return this.__private_singleton_recordData;
     }
-    assert(`Expected store.createRecordDataFor to be implemented but it wasn't`);
+    return cache;
   }
 
+  /**
+   * [DEPRECATED] use Store.createCache
+   *
+   * Instantiation hook allowing applications or addons to configure the store
+   * to utilize a custom RecordData implementation.
+   *
+   * @method createRecordDataFor (hook)
+   * @deprecated
+   * @public
+   * @param identifier
+   * @param storeWrapper
+   * @returns {Cache}
+   */
+
   /**
     `normalize` converts a json payload into the normalized form that
     [push](../methods/push?anchor=push) expects.
@@ -7353,7 +6537,7 @@ class Store {
   */
   // TODO @runspired @deprecate users should call normalize on the associated serializer directly
   normalize(modelName, payload) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'normalize');
     }
     assert(`You need to pass a model name to the store's normalize method`, modelName);
@@ -7378,7 +6562,7 @@ class Store {
     @return Adapter
   */
   adapterFor(modelName) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'adapterFor');
     }
     assert(`You need to pass a model name to the store's adapterFor method`, modelName);
@@ -7444,7 +6628,7 @@ class Store {
     @return {Serializer}
   */
   serializerFor(modelName) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'serializerFor');
     }
     assert(`You need to pass a model name to the store's serializerFor method`, modelName);
@@ -7494,7 +6678,7 @@ class Store {
         serializer.destroy();
       }
     }
-    if (macroCondition(dependencySatisfies("@ember-data/graph", "*"))) {
+    if (macroCondition(getOwnConfig().packages.HAS_GRAPH_PACKAGE)) {
       const peekGraph = importSync('@ember-data/graph/-private').peekGraph;
       let graph = peekGraph(this);
       if (graph) {
@@ -7504,14 +6688,6 @@ class Store {
     this.recordArrayManager.destroy();
     this.identifierCache.destroy();
     this.unloadAll();
-    if (macroCondition(isDevelopingApp())) {
-      unregisterWaiter(this.__asyncWaiter);
-      let tracked = this._trackedAsyncRequests;
-      let isSettled = tracked.length === 0;
-      if (!isSettled) {
-        throw new Error('Async Request leaks detected. Add a breakpoint here and set `store.generateStackTracesForTrackedRequests = true;`to inspect traces for leak origins:\n\t - ' + tracked.map(o => o.label).join('\n\t - '));
-      }
-    }
     this.isDestroyed = true;
   }
   static create(args) {
@@ -7520,7 +6696,7 @@ class Store {
 }
 let assertDestroyingStore;
 let assertDestroyedStoreOnly;
-if (macroCondition(isDevelopingApp())) {
+if (macroCondition(getOwnConfig().env.DEBUG)) {
   assertDestroyingStore = function assertDestroyedStore(store, method) {
     assert(`Attempted to call store.${method}(), but the store instance has already been destroyed.`, !(store.isDestroying || store.isDestroyed));
   };
@@ -7532,68 +6708,11 @@ function isMaybeIdentifier(maybeIdentifier) {
   return Boolean(maybeIdentifier !== null && typeof maybeIdentifier === 'object' && ('id' in maybeIdentifier && 'type' in maybeIdentifier && maybeIdentifier.id && maybeIdentifier.type || maybeIdentifier.lid));
 }
 function isDSModel(record) {
-  if (macroCondition(!dependencySatisfies("@ember-data/model", "*"))) {
+  if (macroCondition(!getOwnConfig().packages.HAS_MODEL_PACKAGE)) {
     return false;
   }
   return !!record && 'constructor' in record && 'isModel' in record.constructor && record.constructor.isModel === true;
 }
-function adapterDidInvalidate(store, identifier, error) {
-  if (error && error.isAdapterError === true && error.code === 'InvalidError') {
-    let serializer = store.serializerFor(identifier.type);
-
-    // TODO @deprecate extractErrors being called
-    // TODO remove extractErrors from the default serializers.
-    if (serializer && typeof serializer.extractErrors === 'function') {
-      let errorsHash = serializer.extractErrors(store, store.modelFor(identifier.type), error, identifier.id);
-      error.errors = errorsHashToArray(errorsHash);
-    }
-  }
-  const recordData = store._instanceCache.getRecordData(identifier);
-  if (error.errors) {
-    assert(`Expected the RecordData implementation for ${identifier} to have a getErrors(identifier) method for retreiving errors.`, typeof recordData.getErrors === 'function');
-    let jsonApiErrors = error.errors;
-    if (jsonApiErrors.length === 0) {
-      jsonApiErrors = [{
-        title: 'Invalid Error',
-        detail: '',
-        source: {
-          pointer: '/data'
-        }
-      }];
-    }
-    recordData.commitWasRejected(identifier, jsonApiErrors);
-  } else {
-    recordData.commitWasRejected(identifier);
-  }
-}
-function makeArray(value) {
-  return Array.isArray(value) ? value : [value];
-}
-const PRIMARY_ATTRIBUTE_KEY = 'base';
-function errorsHashToArray(errors) {
-  const out = [];
-  if (errors) {
-    Object.keys(errors).forEach(key => {
-      let messages = makeArray(errors[key]);
-      for (let i = 0; i < messages.length; i++) {
-        let title = 'Invalid Attribute';
-        let pointer = `/data/attributes/${key}`;
-        if (key === PRIMARY_ATTRIBUTE_KEY) {
-          title = 'Invalid Document';
-          pointer = `/data`;
-        }
-        out.push({
-          title: title,
-          detail: messages[i],
-          source: {
-            pointer: pointer
-          }
-        });
-      }
-    });
-  }
-  return out;
-}
 function normalizeProperties(store, identifier, properties, isForV1 = false) {
   // assert here
   if (properties !== undefined) {
@@ -7617,7 +6736,7 @@ function normalizeProperties(store, identifier, properties, isForV1 = false) {
         let def = defs[prop];
         if (def !== undefined) {
           if (def.kind === 'hasMany') {
-            if (macroCondition(isDevelopingApp())) {
+            if (macroCondition(getOwnConfig().env.DEBUG)) {
               assertRecordsPassedToHasMany(properties[prop]);
             }
             relationshipValue = extractIdentifiersFromRecords(properties[prop], isForV1);
@@ -7651,7 +6770,7 @@ function extractIdentifierFromRecord(recordOrPromiseRecord, isForV1 = false) {
   if (!recordOrPromiseRecord) {
     return null;
   }
-  const extract = isForV1 ? recordDataFor : recordIdentifierFor;
+  const extract = isForV1 ? peekCache : recordIdentifierFor;
   if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
     if (isPromiseRecord(recordOrPromiseRecord)) {
       let content = recordOrPromiseRecord.content;
@@ -7673,11 +6792,108 @@ function extractIdentifierFromRecord(recordOrPromiseRecord, isForV1 = false) {
 function isPromiseRecord(record) {
   return !!record.then;
 }
-function secretInit(record, recordData, identifier, store) {
+function secretInit(record, cache, identifier, store) {
   setRecordIdentifier(record, identifier);
   StoreMap.set(record, store);
-  setRecordDataFor(record, recordData);
+  setCacheFor(record, cache);
+}
+function getHydratedContent(store, request, document) {
+  if (Array.isArray(document.data)) {
+    const {
+      lid
+    } = document;
+    const {
+      recordArrayManager
+    } = store;
+    if (!lid) {
+      return recordArrayManager.createArray({
+        identifiers: document.data,
+        doc: document,
+        query: request
+      });
+    }
+    let managed = recordArrayManager._keyedArrays.get(lid);
+    if (!managed) {
+      managed = recordArrayManager.createArray({
+        identifiers: document.data,
+        doc: document
+      });
+      recordArrayManager._keyedArrays.set(lid, managed);
+    } else {
+      recordArrayManager.populateManagedArray(managed, document.data, document);
+    }
+    return managed;
+  } else {
+    return document.data ? store.peekRecord(document.data) : null;
+  }
+}
+function calcShouldFetch(store, request, hasCachedValue, lid) {
+  const {
+    cacheOptions,
+    url,
+    method
+  } = request;
+  return cacheOptions?.reload || !hasCachedValue || store.lifetimes && lid && url && method ? store.lifetimes.isHardExpired(lid, url, method) : false;
+}
+function calcShouldBackgroundFetch(store, request, willFetch, lid) {
+  const {
+    cacheOptions,
+    url,
+    method
+  } = request;
+  return !willFetch && (cacheOptions?.backgroundReload || store.lifetimes && lid && url && method ? store.lifetimes.isSoftExpired(lid, url, method) : false);
+}
+function fetchContentAndHydrate(next, context, shouldFetch, shouldBackgroundFetch) {
+  const {
+    store
+  } = context.request;
+  return next(context.request).then(document => {
+    const response = store.cache.put(document);
+    if (shouldFetch) {
+      return getHydratedContent(store, context.request, response);
+    }
+  }, error => {
+    store.cache.put(error);
+    // TODO @runspired this is probably not the right thing to throw so make sure we add a test
+    if (!shouldBackgroundFetch) {
+      throw error;
+    }
+  });
 }
+const CacheHandler = {
+  request(context, next) {
+    // if we are a legacy request or did not originate from the store, skip cache handling
+    if (!context.request.store || context.request.op && !context.request.url) {
+      return next(context.request);
+    }
+    const {
+      store
+    } = context.request;
+    const {
+      cacheOptions,
+      url,
+      method
+    } = context.request;
+    const lid = cacheOptions?.key || method === 'GET' && url ? url : null;
+    const peeked = lid ? store.cache.peekRequest({
+      lid
+    }) : null;
+
+    // determine if we should skip cache
+    if (calcShouldFetch(store, context.request, !!peeked, lid)) {
+      return fetchContentAndHydrate(next, context, true, false);
+    }
+
+    // if we have not skipped cache, determine if we should update behind the scenes
+    if (calcShouldBackgroundFetch(store, context.request, false, lid)) {
+      void fetchContentAndHydrate(next, context, false, true);
+    }
+    if ('error' in peeked) {
+      throw peeked.error;
+    }
+    return Promise.resolve(getHydratedContent(store, context.request, peeked.content));
+  }
+};
 function normalizeModelName(modelName) {
   if (macroCondition(getOwnConfig().deprecations.DEPRECATE_HELPERS)) {
     deprecate(`the helper function normalizeModelName is deprecated. You should use model names that are already normalized, or use string helpers of your own. This function is primarily an alias for dasherize from @ember/string.`, false, {
@@ -7693,4 +6909,4 @@ function normalizeModelName(modelName) {
   }
   assert(`normalizeModelName support has been removed`);
 }
-export { Collection as C, IdentifierArray as I, MUTATE as M, RecordArrayManager as R, Store as S, _clearCaches as _, Snapshot as a, setIdentifierGenerationMethod as b, setIdentifierUpdateMethod as c, setIdentifierForgetMethod as d, setIdentifierResetMethod as e, coerceId as f, notifyArray as g, SOURCE as h, isStableIdentifier as i, IDENTIFIER_ARRAY_TAG as j, fastPush as k, SnapshotRecordArray as l, recordDataFor as m, normalizeModelName as n, removeRecordDataFor as o, recordIdentifierFor as r, storeFor as s };
+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, notifyArray as g, SOURCE as h, isStableIdentifier as i, IDENTIFIER_ARRAY_TAG as j, fastPush as k, removeRecordDataFor as l, normalizeModelName as n, peekCache as p, recordIdentifierFor as r, storeFor as s };