@ember-data/store 5.4.0-beta.8 → 5.4.1-alpha.160

package/dist/{cache-handler-C5ilAUZ5.js → many-array-BwVo-2vv.js}

@@ -1,11 +1,12 @@
 import { deprecate, warn } from '@ember/debug';
 import { macroCondition, getGlobalConfig, dependencySatisfies, importSync } from '@embroider/macros';
-import { SkipCache, EnableHydration } from '@warp-drive/core-types/request';
-import { getOrSetGlobal, setTransient, peekTransient } from '@warp-drive/core-types/-private';
-import { CACHE_OWNER, DEBUG_STALE_CACHE_OWNER, DEBUG_CLIENT_ORIGINATED, DEBUG_IDENTIFIER_BUCKET } from '@warp-drive/core-types/identifier';
-import { dasherize } from '@ember-data/request-utils/string';
-import { defineSignal, createSignal, subscribe, createArrayTags, addToTransaction, addTransactionCB } from '@ember-data/tracking/-private';
+import { EnableHydration, SkipCache } from '@warp-drive/core-types/request';
+import { setLogging, getRuntimeConfig } from '@warp-drive/core-types/runtime';
+import { getOrSetGlobal, peekTransient, setTransient } from '@warp-drive/core-types/-private';
 import { _backburner } from '@ember/runloop';
+import { defineSubscription, notifySignal, defineSignal, createSignal, subscribe, createArrayTags, addToTransaction, addTransactionCB } from '@ember-data/tracking/-private';
+import { CACHE_OWNER, DEBUG_STALE_CACHE_OWNER, DEBUG_IDENTIFIER_BUCKET, DEBUG_CLIENT_ORIGINATED } from '@warp-drive/core-types/identifier';
+import { dasherize } from '@ember-data/request-utils/string';
 import { compat } from '@ember-data/tracking';
 
 /**
@@ -25,7 +26,7 @@ function coerceId(id) {
       until: '6.0',
       for: 'ember-data',
       since: {
-        available: '5.3',
+        available: '4.13',
         enabled: '5.3'
       }
     });
@@ -60,7 +61,7 @@ function normalizeModelName(type) {
       until: '6.0',
       for: 'ember-data',
       since: {
-        available: '5.3',
+        available: '4.13',
         enabled: '5.3'
       }
     });
@@ -75,7 +76,7 @@ function normalizeModelName(type) {
 
 function installPolyfill() {
   const isFastBoot = typeof FastBoot !== 'undefined';
-  const CRYPTO = isFastBoot ? FastBoot.require('crypto') : window.crypto;
+  const CRYPTO = isFastBoot ? FastBoot.require('crypto') : globalThis.crypto;
   if (!CRYPTO.randomUUID) {
     // we might be able to optimize this by requesting more bytes than we need at a time
     const rng = function () {
@@ -129,16 +130,15 @@ function hasType(resource) {
 /**
   @module @ember-data/store
 */
-const IDENTIFIERS = getOrSetGlobal('IDENTIFIERS', new Set());
 const DOCUMENTS = getOrSetGlobal('DOCUMENTS', new Set());
 function isStableIdentifier(identifier) {
-  return identifier[CACHE_OWNER] !== undefined || IDENTIFIERS.has(identifier);
+  return identifier[CACHE_OWNER] !== undefined;
 }
 function isDocumentIdentifier(identifier) {
   return DOCUMENTS.has(identifier);
 }
 const isFastBoot = typeof FastBoot !== 'undefined';
-const _crypto = isFastBoot ? FastBoot.require('crypto') : window.crypto;
+const _crypto = isFastBoot ? FastBoot.require('crypto') : globalThis.crypto;
 if (macroCondition(getGlobalConfig().WarpDrive.polyfillUUID)) {
   installPolyfill();
 }
@@ -310,9 +310,11 @@ class IdentifierCache {
    */
 
   _getRecordIdentifier(resource, shouldGenerate) {
-    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
-      // eslint-disable-next-line no-console
-      console.groupCollapsed(`Identifiers: ${shouldGenerate ? 'Generating' : 'Peeking'} Identifier`, resource);
+    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+      if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
+        // eslint-disable-next-line no-console
+        console.groupCollapsed(`Identifiers: ${shouldGenerate ? 'Generating' : 'Peeking'} Identifier`, resource);
+      }
     }
     // short circuit if we're already the stable version
     if (isStableIdentifier(resource)) {
@@ -322,33 +324,41 @@ class IdentifierCache {
           throw new Error(`The supplied identifier ${JSON.stringify(resource)} does not belong to this store instance`);
         }
       }
-      if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
-        // eslint-disable-next-line no-console
-        console.log(`Identifiers: cache HIT - Stable ${resource.lid}`);
-        // eslint-disable-next-line no-console
-        console.groupEnd();
+      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+        if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
+          // eslint-disable-next-line no-console
+          console.log(`Identifiers: cache HIT - Stable ${resource.lid}`);
+          // eslint-disable-next-line no-console
+          console.groupEnd();
+        }
       }
       return resource;
     }
 
     // the resource is unknown, ask the application to identify this data for us
     const lid = this._generate(resource, 'record');
-    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
-      // eslint-disable-next-line no-console
-      console.log(`Identifiers: ${lid ? 'no ' : ''}lid ${lid ? lid + ' ' : ''}determined for resource`, resource);
+    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+      if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
+        // eslint-disable-next-line no-console
+        console.log(`Identifiers: ${lid ? 'no ' : ''}lid ${lid ? lid + ' ' : ''}determined for resource`, resource);
+      }
     }
     let identifier = /*#__NOINLINE__*/getIdentifierFromLid(this._cache, lid, resource);
     if (identifier !== null) {
-      if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
-        // eslint-disable-next-line no-console
-        console.groupEnd();
+      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+        if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
+          // eslint-disable-next-line no-console
+          console.groupEnd();
+        }
       }
       return identifier;
     }
     if (shouldGenerate === 0) {
-      if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
-        // eslint-disable-next-line no-console
-        console.groupEnd();
+      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+        if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
+          // eslint-disable-next-line no-console
+          console.groupEnd();
+        }
       }
       return;
     }
@@ -366,9 +376,11 @@ class IdentifierCache {
       identifier = /*#__NOINLINE__*/makeStableRecordIdentifier(keyInfo, 'record', false);
     }
     addResourceToCache(this._cache, identifier);
-    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
-      // eslint-disable-next-line no-console
-      console.groupEnd();
+    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+      if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
+        // eslint-disable-next-line no-console
+        console.groupEnd();
+      }
     }
     return identifier;
   }
@@ -462,9 +474,11 @@ class IdentifierCache {
 
     /*#__NOINLINE__*/
     addResourceToCache(this._cache, identifier);
-    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
-      // eslint-disable-next-line no-console
-      console.log(`Identifiers: created identifier ${String(identifier)} for newly generated resource`, data);
+    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+      if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
+        // eslint-disable-next-line no-console
+        console.log(`Identifiers: created identifier ${String(identifier)} for newly generated resource`, data);
+      }
     }
     return identifier;
   }
@@ -511,9 +525,11 @@ class IdentifierCache {
       if (hadLid) {
         data.lid = identifier.lid;
       }
-      if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
-        // eslint-disable-next-line no-console
-        console.log(`Identifiers: merged identifiers ${generatedIdentifier.lid} and ${existingIdentifier.lid} for resource into ${identifier.lid}`, data);
+      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+        if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
+          // eslint-disable-next-line no-console
+          console.log(`Identifiers: merged identifiers ${generatedIdentifier.lid} and ${existingIdentifier.lid} for resource into ${identifier.lid}`, data);
+        }
       }
     }
     const id = identifier.id;
@@ -523,9 +539,11 @@ class IdentifierCache {
 
     // add to our own secondary lookup table
     if (id !== newId && newId !== null) {
-      if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
-        // eslint-disable-next-line no-console
-        console.log(`Identifiers: updated id for identifier ${identifier.lid} from '${String(id)}' to '${String(newId)}' for resource`, data);
+      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+        if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
+          // eslint-disable-next-line no-console
+          console.log(`Identifiers: updated id for identifier ${identifier.lid} from '${String(id)}' to '${String(newId)}' for resource`, data);
+        }
       }
       const typeSet = this._cache.resourcesByType[identifier.type];
       macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -537,9 +555,11 @@ class IdentifierCache {
       if (id !== null) {
         typeSet.id.delete(id);
       }
-    } else if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
-      // eslint-disable-next-line no-console
-      console.log(`Identifiers: updated identifier ${identifier.lid} resource`, data);
+    } else if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+      if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
+        // eslint-disable-next-line no-console
+        console.log(`Identifiers: updated identifier ${identifier.lid} resource`, data);
+      }
     }
     return identifier;
   }
@@ -621,11 +641,12 @@ class IdentifierCache {
       identifier[DEBUG_STALE_CACHE_OWNER] = identifier[CACHE_OWNER];
     }
     identifier[CACHE_OWNER] = undefined;
-    IDENTIFIERS.delete(identifier);
     this._forget(identifier, 'record');
-    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
-      // eslint-disable-next-line no-console
-      console.log(`Identifiers: released identifier ${identifierObject.lid}`);
+    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+      if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
+        // eslint-disable-next-line no-console
+        console.log(`Identifiers: released identifier ${identifierObject.lid}`);
+      }
     }
   }
   destroy() {
@@ -637,20 +658,17 @@ class IdentifierCache {
   }
 }
 function makeStableRecordIdentifier(recordIdentifier, bucket, clientOriginated) {
-  IDENTIFIERS.add(recordIdentifier);
   if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
     // we enforce immutability in dev
     //  but preserve our ability to do controlled updates to the reference
     let wrapper = {
-      get lid() {
-        return recordIdentifier.lid;
-      },
+      type: recordIdentifier.type,
+      lid: recordIdentifier.lid,
       get id() {
         return recordIdentifier.id;
-      },
-      get type() {
-        return recordIdentifier.type;
-      },
+      }
+    };
+    const proto = {
       get [CACHE_OWNER]() {
         return recordIdentifier[CACHE_OWNER];
       },
@@ -662,9 +680,15 @@ function makeStableRecordIdentifier(recordIdentifier, bucket, clientOriginated)
       },
       set [DEBUG_STALE_CACHE_OWNER](value) {
         recordIdentifier[DEBUG_STALE_CACHE_OWNER] = value;
+      },
+      get [DEBUG_CLIENT_ORIGINATED]() {
+        return clientOriginated;
+      },
+      get [DEBUG_IDENTIFIER_BUCKET]() {
+        return bucket;
       }
     };
-    Object.defineProperty(wrapper, 'toString', {
+    Object.defineProperty(proto, 'toString', {
       enumerable: false,
       value: () => {
         const {
@@ -675,7 +699,7 @@ function makeStableRecordIdentifier(recordIdentifier, bucket, clientOriginated)
         return `${clientOriginated ? '[CLIENT_ORIGINATED] ' : ''}${String(type)}:${String(id)} (${lid})`;
       }
     });
-    Object.defineProperty(wrapper, 'toJSON', {
+    Object.defineProperty(proto, 'toJSON', {
       enumerable: false,
       value: () => {
         const {
@@ -690,9 +714,7 @@ function makeStableRecordIdentifier(recordIdentifier, bucket, clientOriginated)
         };
       }
     });
-    wrapper[DEBUG_CLIENT_ORIGINATED] = clientOriginated;
-    wrapper[DEBUG_IDENTIFIER_BUCKET] = bucket;
-    IDENTIFIERS.add(wrapper);
+    Object.setPrototypeOf(wrapper, proto);
     DEBUG_MAP.set(wrapper, recordIdentifier);
     wrapper = freeze(wrapper);
     return wrapper;
@@ -775,9 +797,11 @@ function detectMerge(cache, keyInfo, identifier, data) {
 }
 function getIdentifierFromLid(cache, lid, resource) {
   const identifier = cache.resources.get(lid);
-  if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
-    // eslint-disable-next-line no-console
-    console.log(`Identifiers: cache ${identifier ? 'HIT' : 'MISS'} - Non-Stable ${lid}`, resource);
+  if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+    if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
+      // eslint-disable-next-line no-console
+      console.log(`Identifiers: cache ${identifier ? 'HIT' : 'MISS'} - Non-Stable ${lid}`, resource);
+    }
   }
   return identifier || null;
 }
@@ -796,88 +820,473 @@ function addResourceToCache(cache, identifier) {
     typeSet.id.set(identifier.id, identifier);
   }
 }
+const TEXT_COLORS = {
+  TEXT: 'inherit',
+  notify: ['white', 'white', 'inherit', 'magenta', 'inherit'],
+  'reactive-ui': ['white', 'white', 'inherit', 'magenta', 'inherit'],
+  graph: ['white', 'white', 'inherit', 'magenta', 'inherit'],
+  request: ['white', 'white', 'inherit', 'magenta', 'inherit'],
+  cache: ['white', 'white', 'inherit', 'magenta', 'inherit']
+};
+const BG_COLORS = {
+  TEXT: 'transparent',
+  notify: ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent'],
+  'reactive-ui': ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent'],
+  graph: ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent'],
+  request: ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent'],
+  cache: ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent']
+};
+const NOTIFY_BORDER = {
+  TEXT: 0,
+  notify: [3, 2, 0, 0, 0],
+  'reactive-ui': [3, 2, 0, 0, 0],
+  graph: [3, 2, 0, 0, 0],
+  request: [3, 2, 0, 0, 0],
+  cache: [3, 2, 0, 0, 0]
+};
+const LIGHT_DARK_ALT = {
+  lightgreen: 'green',
+  green: 'lightgreen'
+};
+function badge(isLight, color, bgColor, border) {
+  return [`color: ${correctColor(isLight, color)}; background-color: ${correctColor(isLight, bgColor)}; padding: ${border}px ${2 * border}px; border-radius: ${border}px;`, `color: ${TEXT_COLORS.TEXT}; background-color: ${BG_COLORS.TEXT};`];
+}
+function colorForBucket(isLight, scope, bucket) {
+  if (scope === 'notify') {
+    return bucket === 'added' ? badge(isLight, 'lightgreen', 'transparent', 0) : bucket === 'removed' ? badge(isLight, 'red', 'transparent', 0) : badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]);
+  }
+  if (scope === 'reactive-ui') {
+    return bucket === 'created' ? badge(isLight, 'lightgreen', 'transparent', 0) : bucket === 'disconnected' ? badge(isLight, 'red', 'transparent', 0) : badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]);
+  }
+  if (scope === 'cache') {
+    return bucket === 'inserted' ? badge(isLight, 'lightgreen', 'transparent', 0) : bucket === 'removed' ? badge(isLight, 'red', 'transparent', 0) : badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]);
+  }
+  return badge(isLight, TEXT_COLORS[scope][3], BG_COLORS[scope][3], NOTIFY_BORDER[scope][3]);
+}
+function logGroup(scope, prefix, subScop1, subScop2, subScop3, subScop4) {
+  // eslint-disable-next-line no-console
+  console.groupCollapsed(..._log(scope, prefix, subScop1, subScop2, subScop3, subScop4));
+}
+function log(scope, prefix, subScop1, subScop2, subScop3, subScop4) {
+  // eslint-disable-next-line no-console
+  console.log(..._log(scope, prefix, subScop1, subScop2, subScop3, subScop4));
+}
+function correctColor(isLight, color) {
+  if (!isLight) {
+    return color;
+  }
+  return color in LIGHT_DARK_ALT ? LIGHT_DARK_ALT[color] : color;
+}
+function isLightMode() {
+  if (window?.matchMedia?.('(prefers-color-scheme: light)').matches) {
+    return true;
+  }
+  return false;
+}
+function _log(scope, prefix, subScop1, subScop2, subScop3, subScop4) {
+  const isLight = isLightMode();
+  switch (scope) {
+    case 'reactive-ui':
+    case 'notify':
+      {
+        const scopePath = prefix ? `[${prefix}] ${scope}` : scope;
+        const path = subScop4 ? `${subScop3}.${subScop4}` : subScop3;
+        return [`%c@warp%c-%cdrive%c %c${scopePath}%c %c${subScop1}%c %c${subScop2}%c %c${path}%c`, ...badge(isLight, 'lightgreen', 'transparent', 0), ...badge(isLight, 'magenta', 'transparent', 0), ...badge(isLight, TEXT_COLORS[scope][0], BG_COLORS[scope][0], NOTIFY_BORDER[scope][0]), ...badge(isLight, TEXT_COLORS[scope][1], BG_COLORS[scope][1], NOTIFY_BORDER[scope][1]), ...badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]), ...colorForBucket(isLight, scope, path)];
+      }
+    case 'cache':
+      {
+        const scopePath = prefix ? `${scope} (${prefix})` : scope;
+        return [`%c@warp%c-%cdrive%c %c${scopePath}%c %c${subScop1}%c %c${subScop2}%c %c${subScop3}%c %c${subScop4}%c`, ...badge(isLight, 'lightgreen', 'transparent', 0), ...badge(isLight, 'magenta', 'transparent', 0), ...badge(isLight, TEXT_COLORS[scope][0], BG_COLORS[scope][0], NOTIFY_BORDER[scope][0]), ...badge(isLight, TEXT_COLORS[scope][1], BG_COLORS[scope][1], NOTIFY_BORDER[scope][1]), ...badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]), ...colorForBucket(isLight, scope, subScop3), ...badge(isLight, TEXT_COLORS[scope][4], BG_COLORS[scope][4], NOTIFY_BORDER[scope][4])];
+      }
+  }
+  return [];
+}
 
 /**
-  @module @ember-data/store
-*/
+ * @module @ember-data/store
+ */
+function urlFromLink(link) {
+  if (typeof link === 'string') return link;
+  return link.href;
+}
 
 /**
-   A `RecordReference` is a low-level API that allows users and
-   addon authors to perform meta-operations on a record.
+ * A Document is a class that wraps the response content from a request to the API
+ * returned by `Cache.put` or `Cache.peek`, converting resource-identifiers into
+ * record instances.
+ *
+ * It is not directly instantiated by the user, and its properties should not
+ * be directly modified. Whether individual properties are mutable or not is
+ * determined by the record instance itself.
+ *
+ * @public
+ * @class ReactiveDocument
+ */
+class ReactiveDocument {
+  /**
+   * The links object for this document, if any
+   *
+   * e.g.
+   *
+   * ```
+   * {
+   *   self: '/articles?page[number]=3',
+   * }
+   * ```
+   *
+   * @property links
+   * @type {object|undefined} - a links object
+   * @public
+   */
 
-   @class RecordReference
-   @public
-*/
-class RecordReference {
-  // unsubscribe token given to us by the notification manager
-  ___token;
-  ___identifier;
-  constructor(store, identifier) {
-    this.store = store;
-    this.___identifier = identifier;
-    this.___token = store.notifications.subscribe(identifier, (_, bucket, notifiedKey) => {
-      if (bucket === 'identity' || bucket === 'attributes' && notifiedKey === 'id') {
-        this._ref++;
-      }
-    });
-  }
-  destroy() {
-    this.store.notifications.unsubscribe(this.___token);
-  }
-  get type() {
-    return this.identifier().type;
-  }
+  /**
+   * The primary data for this document, if any.
+   *
+   * If this document has no primary data (e.g. because it is an error document)
+   * this property will be `undefined`.
+   *
+   * For collections this will be an array of record instances,
+   * for single resource requests it will be a single record instance or null.
+   *
+   * @property data
+   * @public
+   * @type {object|Array<object>|null|undefined} - a data object
+   */
 
   /**
-     The `id` of the record that this reference refers to.
-      Together, the `type` and `id` properties form a composite key for
-     the identity map.
-      Example
-      ```javascript
-     let userRef = store.getReference('user', 1);
-      userRef.id(); // '1'
-     ```
-      @method id
-    @public
-     @return {String} The id of the record.
-  */
-  id() {
-    this._ref; // consume the tracked prop
-    return this.___identifier.id;
+   * The errors returned by the API for this request, if any
+   *
+   * @property errors
+   * @public
+   * @type {object|undefined} - an errors object
+   */
+
+  /**
+   * The meta object for this document, if any
+   *
+   * @property meta
+   * @public
+   * @type {object|undefined} - a meta object
+   */
+
+  /**
+   * The identifier associated with this document, if any
+   *
+   * @property identifier
+   * @public
+   * @type {StableDocumentIdentifier|null}
+   */
+
+  constructor(store, identifier, localCache) {
+    this._store = store;
+    this._localCache = localCache;
+    this.identifier = identifier;
+
+    // TODO if we ever enable auto-cleanup of the cache, we will need to tear this down
+    // in a destroy method
+    if (identifier) {
+      store.notifications.subscribe(identifier, (_identifier, type) => {
+        switch (type) {
+          case 'updated':
+            // FIXME in the case of a collection we need to notify it's length
+            // and have it recalc
+            notifySignal(this, 'data');
+            notifySignal(this, 'links');
+            notifySignal(this, 'meta');
+            notifySignal(this, 'errors');
+            break;
+        }
+      });
+    }
+  }
+  async #request(link, options) {
+    const href = this.links?.[link];
+    if (!href) {
+      return null;
+    }
+    options.method = options.method || 'GET';
+    Object.assign(options, {
+      url: urlFromLink(href)
+    });
+    const response = await this._store.request(options);
+    return response.content;
   }
 
   /**
-     The `identifier` of the record that this reference refers to.
-      Together, the `type` and `id` properties form a composite key for
-     the identity map.
-      Example
-      ```javascript
-     let userRef = store.getReference('user', 1);
-      userRef.identifier(); // '1'
-     ```
-      @method identifier
-    @public
-     @return {String} The identifier of the record.
-  */
-  identifier() {
-    return this.___identifier;
+   * Fetches the related link for this document, returning a promise that resolves
+   * with the document when the request completes. If no related link is present,
+   * will fallback to the self link if present
+   *
+   * @method fetch
+   * @public
+   * @param {object} options
+   * @return Promise<Document>
+   */
+  fetch(options = {}) {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`No self or related link`);
+      }
+    })(this.links?.related || this.links?.self) : {};
+    options.cacheOptions = options.cacheOptions || {};
+    options.cacheOptions.key = this.identifier?.lid;
+    return this.#request(this.links.related ? 'related' : 'self', options);
   }
 
   /**
-     How the reference will be looked up when it is loaded. Currently
-     this always returns `identity` to signify that a record will be
-     loaded by its `type` and `id`.
-      Example
-      ```javascript
-     const userRef = store.getReference('user', 1);
-      userRef.remoteType(); // 'identity'
-     ```
-      @method remoteType
-     @public
-     @return {String} 'identity'
-  */
-  remoteType() {
-    return 'identity';
+   * Fetches the next link for this document, returning a promise that resolves
+   * with the new document when the request completes, or null  if there is no
+   * next link.
+   *
+   * @method next
+   * @public
+   * @param {object} options
+   * @return Promise<Document | null>
+   */
+  next(options = {}) {
+    return this.#request('next', options);
+  }
+
+  /**
+   * Fetches the prev link for this document, returning a promise that resolves
+   * with the new document when the request completes, or null if there is no
+   * prev link.
+   *
+   * @method prev
+   * @public
+   * @param {object} options
+   * @return Promise<Document | null>
+   */
+  prev(options = {}) {
+    return this.#request('prev', options);
+  }
+
+  /**
+   * Fetches the first link for this document, returning a promise that resolves
+   * with the new document when the request completes, or null if there is no
+   * first link.
+   *
+   * @method first
+   * @public
+   * @param {object} options
+   * @return Promise<Document | null>
+   */
+  first(options = {}) {
+    return this.#request('first', options);
+  }
+
+  /**
+   * Fetches the last link for this document, returning a promise that resolves
+   * with the new document when the request completes, or null if there is no
+   * last link.
+   *
+   * @method last
+   * @public
+   * @param {object} options
+   * @return Promise<Document | null>
+   */
+  last(options = {}) {
+    return this.#request('last', options);
+  }
+
+  /**
+   * Implemented for `JSON.stringify` support.
+   *
+   * Returns the JSON representation of the document wrapper.
+   *
+   * This is a shallow serialization, it does not deeply serialize
+   * the document's contents, leaving that to the individual record
+   * instances to determine how to do, if at all.
+   *
+   * @method toJSON
+   * @public
+   * @return
+   */
+  toJSON() {
+    const data = {};
+    data.identifier = this.identifier;
+    if (this.data !== undefined) {
+      data.data = this.data;
+    }
+    if (this.links !== undefined) {
+      data.links = this.links;
+    }
+    if (this.errors !== undefined) {
+      data.errors = this.errors;
+    }
+    if (this.meta !== undefined) {
+      data.meta = this.meta;
+    }
+    return data;
+  }
+}
+defineSubscription(ReactiveDocument.prototype, 'errors', {
+  get() {
+    const {
+      identifier
+    } = this;
+    if (!identifier) {
+      const {
+        document
+      } = this._localCache;
+      if ('errors' in document) {
+        return document.errors;
+      }
+      return;
+    }
+    const doc = this._store.cache.peek(identifier);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`No cache data was found for the document '${identifier.lid}'`);
+      }
+    })(doc) : {};
+    return 'errors' in doc ? doc.errors : undefined;
+  }
+});
+defineSubscription(ReactiveDocument.prototype, 'data', {
+  get() {
+    const {
+      identifier,
+      _localCache
+    } = this;
+    const doc = identifier ? this._store.cache.peek(identifier) : _localCache.document;
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`No cache data was found for the document '${identifier?.lid ?? '<uncached document>'}'`);
+      }
+    })(doc) : {};
+    const data = 'data' in doc ? doc.data : undefined;
+    if (Array.isArray(data)) {
+      return this._store.recordArrayManager.getCollection({
+        type: identifier ? identifier.lid : _localCache.request.url,
+        identifiers: data.slice(),
+        doc: identifier ? undefined : doc,
+        identifier: identifier ?? null
+      });
+    } else if (data) {
+      return this._store.peekRecord(data);
+    } else {
+      return data;
+    }
+  }
+});
+defineSubscription(ReactiveDocument.prototype, 'links', {
+  get() {
+    const {
+      identifier
+    } = this;
+    if (!identifier) {
+      return this._localCache.document.links;
+    }
+    const data = this._store.cache.peek(identifier);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`No cache data was found for the document '${identifier.lid}'`);
+      }
+    })(data) : {};
+    return data.links;
+  }
+});
+defineSubscription(ReactiveDocument.prototype, 'meta', {
+  get() {
+    const {
+      identifier
+    } = this;
+    if (!identifier) {
+      return this._localCache.document.meta;
+    }
+    const data = this._store.cache.peek(identifier);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`No cache data was found for the document '${identifier.lid}'`);
+      }
+    })(data) : {};
+    return data.meta;
+  }
+});
+
+/**
+  @module @ember-data/store
+*/
+
+/**
+   A `RecordReference` is a low-level API that allows users and
+   addon authors to perform meta-operations on a record.
+
+   @class RecordReference
+   @public
+*/
+class RecordReference {
+  // unsubscribe token given to us by the notification manager
+  ___token;
+  ___identifier;
+  constructor(store, identifier) {
+    this.store = store;
+    this.___identifier = identifier;
+    this.___token = store.notifications.subscribe(identifier, (_, bucket, notifiedKey) => {
+      if (bucket === 'identity' || bucket === 'attributes' && notifiedKey === 'id') {
+        this._ref++;
+      }
+    });
+  }
+  destroy() {
+    this.store.notifications.unsubscribe(this.___token);
+  }
+  get type() {
+    return this.identifier().type;
+  }
+
+  /**
+     The `id` of the record that this reference refers to.
+      Together, the `type` and `id` properties form a composite key for
+     the identity map.
+      Example
+      ```javascript
+     let userRef = store.getReference('user', 1);
+      userRef.id(); // '1'
+     ```
+      @method id
+    @public
+     @return {String} The id of the record.
+  */
+  id() {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    this._ref; // consume the tracked prop
+    return this.___identifier.id;
+  }
+
+  /**
+     The `identifier` of the record that this reference refers to.
+      Together, the `type` and `id` properties form a composite key for
+     the identity map.
+      Example
+      ```javascript
+     let userRef = store.getReference('user', 1);
+      userRef.identifier(); // '1'
+     ```
+      @method identifier
+    @public
+     @return {String} The identifier of the record.
+  */
+  identifier() {
+    return this.___identifier;
+  }
+
+  /**
+     How the reference will be looked up when it is loaded. Currently
+     this always returns `identity` to signify that a record will be
+     loaded by its `type` and `id`.
+      Example
+      ```javascript
+     const userRef = store.getReference('user', 1);
+      userRef.remoteType(); // 'identity'
+     ```
+      @method remoteType
+     @public
+     @return {String} 'identity'
+  */
+  remoteType() {
+    return 'identity';
   }
 
   /**
@@ -1176,12 +1585,13 @@ function storeFor(record) {
   return store;
 }
 class InstanceCache {
-  __instances = {
-    record: new Map(),
-    reference: new WeakMap()
-  };
   constructor(store) {
     this.store = store;
+    this.__instances = {
+      record: new Map(),
+      reference: new WeakMap(),
+      document: new Map()
+    };
     this._storeWrapper = new CacheCapabilitiesManager(this.store);
     store.identifierCache.__configureMerge((identifier, matchedIdentifier, resourceData) => {
       let keptIdentifier = identifier;
@@ -1236,6 +1646,14 @@ class InstanceCache {
   peek(identifier) {
     return this.__instances.record.get(identifier);
   }
+  getDocument(identifier) {
+    let doc = this.__instances.document.get(identifier);
+    if (!doc) {
+      doc = new ReactiveDocument(this.store, identifier, null);
+      this.__instances.document.set(identifier, doc);
+    }
+    return doc;
+  }
   getRecord(identifier, properties) {
     let record = this.__instances.record.get(identifier);
     if (!record) {
@@ -1251,9 +1669,16 @@ class InstanceCache {
       setCacheFor(record, cache);
       StoreMap.set(record, this.store);
       this.__instances.record.set(identifier, record);
-      if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE)) {
-        // eslint-disable-next-line no-console
-        console.log(`InstanceCache: created Record for ${String(identifier)}`, properties);
+      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_INSTANCE_CACHE)) {
+        if (getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE || globalThis.getWarpDriveRuntimeConfig().debug.LOG_INSTANCE_CACHE) {
+          logGroup('reactive-ui', '', identifier.type, identifier.lid, 'created', '');
+          // eslint-disable-next-line no-console
+          console.log({
+            properties
+          });
+          // eslint-disable-next-line no-console
+          console.groupEnd();
+        }
       }
     }
     return record;
@@ -1299,9 +1724,10 @@ class InstanceCache {
     this.store.identifierCache.forgetRecordIdentifier(identifier);
     removeRecordDataFor(identifier);
     this.store._requestCache._clearEntries(identifier);
-    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE)) {
-      // eslint-disable-next-line no-console
-      console.log(`InstanceCache: disconnected ${String(identifier)}`);
+    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_INSTANCE_CACHE)) {
+      if (getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE || globalThis.getWarpDriveRuntimeConfig().debug.LOG_INSTANCE_CACHE) {
+        log('reactive-ui', '', identifier.type, identifier.lid, 'disconnected', '');
+      }
     }
   }
   unloadRecord(identifier) {
@@ -1317,9 +1743,11 @@ class InstanceCache {
         })() : {};
       }
     }
-    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE)) {
-      // eslint-disable-next-line no-console
-      console.groupCollapsed(`InstanceCache: unloading record for ${String(identifier)}`);
+    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_INSTANCE_CACHE)) {
+      if (getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE || globalThis.getWarpDriveRuntimeConfig().debug.LOG_INSTANCE_CACHE) {
+        // eslint-disable-next-line no-console
+        console.groupCollapsed(`InstanceCache: unloading record for ${String(identifier)}`);
+      }
     }
 
     // TODO is this join still necessary?
@@ -1332,27 +1760,33 @@ class InstanceCache {
         StoreMap.delete(record);
         RecordCache.delete(record);
         removeRecordDataFor(record);
-        if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE)) {
-          // eslint-disable-next-line no-console
-          console.log(`InstanceCache: destroyed record for ${String(identifier)}`);
+        if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_INSTANCE_CACHE)) {
+          if (getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE || globalThis.getWarpDriveRuntimeConfig().debug.LOG_INSTANCE_CACHE) {
+            // eslint-disable-next-line no-console
+            console.log(`InstanceCache: destroyed record for ${String(identifier)}`);
+          }
         }
       }
       if (cache) {
         cache.unloadRecord(identifier);
         removeRecordDataFor(identifier);
-        if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE)) {
-          // eslint-disable-next-line no-console
-          console.log(`InstanceCache: destroyed cache for ${String(identifier)}`);
+        if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_INSTANCE_CACHE)) {
+          if (getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE || globalThis.getWarpDriveRuntimeConfig().debug.LOG_INSTANCE_CACHE) {
+            // eslint-disable-next-line no-console
+            console.log(`InstanceCache: destroyed cache for ${String(identifier)}`);
+          }
         }
       } else {
         this.disconnect(identifier);
       }
       this.store._requestCache._clearEntries(identifier);
-      if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE)) {
-        // eslint-disable-next-line no-console
-        console.log(`InstanceCache: unloaded RecordData for ${String(identifier)}`);
-        // eslint-disable-next-line no-console
-        console.groupEnd();
+      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_INSTANCE_CACHE)) {
+        if (getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE || globalThis.getWarpDriveRuntimeConfig().debug.LOG_INSTANCE_CACHE) {
+          // eslint-disable-next-line no-console
+          console.log(`InstanceCache: unloaded RecordData for ${String(identifier)}`);
+          // eslint-disable-next-line no-console
+          console.groupEnd();
+        }
       }
     });
   }
@@ -1407,9 +1841,11 @@ class InstanceCache {
       warn(`Your ${type} record was saved to the server, but the response does not have an id.`, !(oldId !== null && id === null));
       return;
     }
-    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE)) {
-      // eslint-disable-next-line no-console
-      console.log(`InstanceCache: updating id to '${id}' for record ${String(identifier)}`);
+    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_INSTANCE_CACHE)) {
+      if (getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE || globalThis.getWarpDriveRuntimeConfig().debug.LOG_INSTANCE_CACHE) {
+        // eslint-disable-next-line no-console
+        console.log(`InstanceCache: updating id to '${id}' for record ${String(identifier)}`);
+      }
     }
     const existingIdentifier = this.store.identifierCache.peekRecordIdentifier({
       type,
@@ -1726,7 +2162,9 @@ class CacheManager {
   peek(identifier) {
     return this.#cache.peek(identifier);
   }
-
+  peekRemoteState(identifier) {
+    return this.#cache.peekRemoteState(identifier);
+  }
   /**
    * Peek the Cache for the existing request data associated with
    * a cacheable request
@@ -1949,6 +2387,19 @@ class CacheManager {
     return this.#cache.getAttr(identifier, propertyName);
   }
 
+  /**
+   * Retrieve the remote state for an attribute from the cache
+   *
+   * @method getRemoteAttr
+   * @public
+   * @param identifier
+   * @param propertyName
+   * @return {unknown}
+   */
+  getRemoteAttr(identifier, propertyName) {
+    return this.#cache.getRemoteAttr(identifier, propertyName);
+  }
+
   /**
    * Mutate the data for an attribute in the cache
    *
@@ -2073,6 +2524,19 @@ class CacheManager {
     return this.#cache.getRelationship(identifier, propertyName);
   }
 
+  /**
+   * Query the cache for the remote state of a relationship property
+   *
+   * @method getRelationship
+   * @public
+   * @param identifier
+   * @param propertyName
+   * @return resource relationship object
+   */
+  getRemoteRelationship(identifier, propertyName) {
+    return this.#cache.getRemoteRelationship(identifier, propertyName);
+  }
+
   // Resource State
   // ===============
 
@@ -2156,28 +2620,52 @@ class CacheManager {
 /**
  * @module @ember-data/store
  */
-// eslint-disable-next-line no-restricted-imports
-let tokenId = 0;
-const CacheOperations = new Set(['added', 'removed', 'state', 'updated']);
+
 function isCacheOperationValue(value) {
-  return CacheOperations.has(value);
+  return value === 'added' || value === 'state' || value === 'updated' || value === 'removed' || value === 'invalidated';
 }
 function runLoopIsFlushing() {
   //@ts-expect-error
   return !!_backburner.currentInstance && _backburner._autorun !== true;
 }
-function _unsubscribe(tokens, token, cache) {
-  const identifier = tokens.get(token);
-  if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS)) {
-    if (!identifier) {
-      // eslint-disable-next-line no-console
-      console.log('Passed unknown unsubscribe token to unsubscribe', identifier);
+function count(label) {
+  // @ts-expect-error
+  // eslint-disable-next-line
+  globalThis.__WarpDriveMetricCountData[label] = (globalThis.__WarpDriveMetricCountData[label] || 0) + 1;
+}
+function asInternalToken(token) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected a token with a 'for' property`);
+    }
+  })(token && typeof token === 'function' && 'for' in token) : {};
+}
+function _unsubscribe(token, cache) {
+  asInternalToken(token);
+  const identifier = token.for;
+  if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_NOTIFICATIONS)) {
+    if (getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_NOTIFICATIONS) {
+      if (!identifier) {
+        // eslint-disable-next-line no-console
+        console.log('Passed unknown unsubscribe token to unsubscribe', identifier);
+      }
     }
   }
   if (identifier) {
-    tokens.delete(token);
-    const map = cache.get(identifier);
-    map?.delete(token);
+    const callbacks = cache.get(identifier);
+    if (!callbacks) {
+      return;
+    }
+    const index = callbacks.indexOf(token);
+    if (index === -1) {
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Cannot unsubscribe a token that is not subscribed`);
+        }
+      })(index !== -1) : {};
+      return;
+    }
+    callbacks.splice(index, 1);
   }
 }
 
@@ -2198,7 +2686,6 @@ class NotificationManager {
     this._buffered = new Map();
     this._hasFlush = false;
     this._cache = new Map();
-    this._tokens = new Map();
   }
 
   /**
@@ -2235,17 +2722,26 @@ class NotificationManager {
         throw new Error(`Expected to receive a stable Identifier to subscribe to`);
       }
     })(identifier === 'resource' || identifier === 'document' || isStableIdentifier(identifier) || isDocumentIdentifier(identifier)) : {};
-    let map = this._cache.get(identifier);
-    if (!map) {
-      map = new Map();
-      this._cache.set(identifier, map);
+    let callbacks = this._cache.get(identifier);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`expected to receive a valid callback`);
+      }
+    })(typeof callback === 'function') : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`cannot subscribe with the same callback twice`);
+      }
+    })(!callbacks || !callbacks.includes(callback)) : {};
+    // we use the callback as the cancellation token
+    //@ts-expect-error
+    callback.for = identifier;
+    if (!callbacks) {
+      callbacks = [];
+      this._cache.set(identifier, callbacks);
     }
-    const unsubToken = macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? {
-      _tokenRef: tokenId++
-    } : {};
-    map.set(unsubToken, callback);
-    this._tokens.set(unsubToken, identifier);
-    return unsubToken;
+    callbacks.push(callback);
+    return callback;
   }
 
   /**
@@ -2257,7 +2753,7 @@ class NotificationManager {
    */
   unsubscribe(token) {
     if (!this.isDestroyed) {
-      _unsubscribe(this._tokens, token, this._cache);
+      _unsubscribe(token, this._cache);
     }
   }
 
@@ -2279,17 +2775,15 @@ class NotificationManager {
       }
     })(!key || value === 'attributes' || value === 'relationships') : {};
     if (!isStableIdentifier(identifier) && !isDocumentIdentifier(identifier)) {
-      if (macroCondition(getGlobalConfig().WarpDrive.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);
+      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_NOTIFICATIONS)) {
+        if (getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().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);
+        }
       }
       return false;
     }
-    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS)) {
-      // eslint-disable-next-line no-console
-      console.log(`Buffering Notify: ${String(identifier.lid)}\t${value}\t${key || ''}`);
-    }
-    const hasSubscribers = Boolean(this._cache.get(identifier)?.size);
+    const hasSubscribers = Boolean(this._cache.get(identifier)?.length);
     if (isCacheOperationValue(value) || hasSubscribers) {
       let buffer = this._buffered.get(identifier);
       if (!buffer) {
@@ -2297,7 +2791,29 @@ class NotificationManager {
         this._buffered.set(identifier, buffer);
       }
       buffer.push([value, key]);
-      this._scheduleNotify();
+      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_METRIC_COUNTS)) {
+        if (getGlobalConfig().WarpDrive.debug.LOG_METRIC_COUNTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_METRIC_COUNTS) {
+          count(`notify ${'type' in identifier ? identifier.type : '<document>'} ${value} ${key}`);
+        }
+      }
+      if (!this._scheduleNotify()) {
+        if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_NOTIFICATIONS)) {
+          if (getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_NOTIFICATIONS) {
+            log('notify', 'buffered', `${'type' in identifier ? identifier.type : 'document'}`, identifier.lid, `${value}`, key || '');
+          }
+        }
+      }
+    } else {
+      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_NOTIFICATIONS)) {
+        if (getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_NOTIFICATIONS) {
+          log('notify', 'discarded', `${'type' in identifier ? identifier.type : 'document'}`, identifier.lid, `${value}`, key || '');
+        }
+      }
+      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_METRIC_COUNTS)) {
+        if (getGlobalConfig().WarpDrive.debug.LOG_METRIC_COUNTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_METRIC_COUNTS) {
+          count(`DISCARDED notify ${'type' in identifier ? identifier.type : '<document>'} ${value} ${key}`);
+        }
+      }
     }
     return hasSubscribers;
   }
@@ -2308,33 +2824,36 @@ class NotificationManager {
     const asyncFlush = this.store._enableAsyncFlush;
     if (this._hasFlush) {
       if (asyncFlush !== false && !runLoopIsFlushing()) {
-        return;
+        return false;
       }
     }
     if (asyncFlush && !runLoopIsFlushing()) {
       this._hasFlush = true;
-      return;
+      return false;
     }
     this._flush();
+    return true;
   }
   _flush() {
-    if (this._buffered.size) {
-      this._buffered.forEach((states, identifier) => {
+    const buffered = this._buffered;
+    if (buffered.size) {
+      this._buffered = new Map();
+      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(getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS)) {
-      // eslint-disable-next-line no-console
-      console.log(`Notifying: ${String(identifier)}\t${value}\t${key || ''}`);
+    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_NOTIFICATIONS)) {
+      if (getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_NOTIFICATIONS) {
+        log('notify', '', `${'type' in identifier ? identifier.type : 'document'}`, identifier.lid, `${value}`, key || '');
+      }
     }
 
     // TODO for documents this will need to switch based on Identifier kind
@@ -2346,11 +2865,11 @@ class NotificationManager {
         });
       }
     }
-    const callbackMap = this._cache.get(identifier);
-    if (!callbackMap || !callbackMap.size) {
+    const callbacks = this._cache.get(identifier);
+    if (!callbacks || !callbacks.length) {
       return false;
     }
-    callbackMap.forEach(cb => {
+    callbacks.forEach(cb => {
       // @ts-expect-error overload doesn't narrow within body
       cb(identifier, value, key);
     });
@@ -2358,7 +2877,6 @@ class NotificationManager {
   }
   destroy() {
     this.isDestroyed = true;
-    this._tokens.clear();
     this._cache.clear();
   }
 }
@@ -2372,71 +2890,6 @@ class NotificationManager {
 */
 
 const NativeProxy = Proxy;
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all) __defProp(target, name, {
-    get: all[name],
-    enumerable: true
-  });
-};
-
-// src/runtime.ts
-var runtime_exports = {};
-__export(runtime_exports, {
-  c: () => decorateClass,
-  f: () => decorateFieldV1,
-  g: () => decorateFieldV2,
-  i: () => initializeDeferredDecorator,
-  m: () => decorateMethodV1,
-  n: () => decorateMethodV2,
-  p: () => decoratePOJO
-});
-var deferred = /* @__PURE__ */new WeakMap();
-function deferDecorator(proto, prop, desc) {
-  let map = deferred.get(proto);
-  if (!map) {
-    map = /* @__PURE__ */new Map();
-    deferred.set(proto, map);
-  }
-  map.set(prop, desc);
-}
-function findDeferredDecorator(target, prop) {
-  let cursor = target.prototype;
-  while (cursor) {
-    let desc = deferred.get(cursor)?.get(prop);
-    if (desc) {
-      return desc;
-    }
-    cursor = cursor.prototype;
-  }
-}
-function decorateFieldV1(target, prop, decorators, initializer) {
-  return decorateFieldV2(target.prototype, prop, decorators, initializer);
-}
-function decorateFieldV2(prototype, prop, decorators, initializer) {
-  let desc = {
-    configurable: true,
-    enumerable: true,
-    writable: true,
-    initializer: null
-  };
-  if (initializer) {
-    desc.initializer = initializer;
-  }
-  for (let decorator of decorators) {
-    desc = decorator(prototype, prop, desc) || desc;
-  }
-  if (desc.initializer === void 0) {
-    Object.defineProperty(prototype, prop, desc);
-  } else {
-    deferDecorator(prototype, prop, desc);
-  }
-}
-function decorateMethodV1({
-  prototype
-}, prop, decorators) {
-  return decorateMethodV2(prototype, prop, decorators);
-}
 function decorateMethodV2(prototype, prop, decorators) {
   const origDesc = Object.getOwnPropertyDescriptor(prototype, prop);
   let desc = {
@@ -2451,46 +2904,6 @@ function decorateMethodV2(prototype, prop, decorators) {
   }
   Object.defineProperty(prototype, prop, desc);
 }
-function initializeDeferredDecorator(target, prop) {
-  let desc = findDeferredDecorator(target.constructor, prop);
-  if (desc) {
-    Object.defineProperty(target, prop, {
-      enumerable: desc.enumerable,
-      configurable: desc.configurable,
-      writable: desc.writable,
-      value: desc.initializer ? desc.initializer.call(target) : void 0
-    });
-  }
-}
-function decorateClass(target, decorators) {
-  return decorators.reduce((accum, decorator) => decorator(accum) || accum, target);
-}
-function decoratePOJO(pojo, decorated) {
-  for (let [type, prop, decorators] of decorated) {
-    if (type === "field") {
-      decoratePojoField(pojo, prop, decorators);
-    } else {
-      decorateMethodV2(pojo, prop, decorators);
-    }
-  }
-  return pojo;
-}
-function decoratePojoField(pojo, prop, decorators) {
-  let desc = {
-    configurable: true,
-    enumerable: true,
-    writable: true,
-    initializer: () => Object.getOwnPropertyDescriptor(pojo, prop)?.value
-  };
-  for (let decorator of decorators) {
-    desc = decorator(pojo, prop, desc) || desc;
-  }
-  if (desc.initializer) {
-    desc.value = desc.initializer.call(pojo);
-    delete desc.initializer;
-  }
-  Object.defineProperty(pojo, prop, desc);
-}
 
 /**
   @module @ember-data/store
@@ -2577,6 +2990,7 @@ class IdentifierArray {
   isDestroying = false;
   isDestroyed = false;
   _updatingPromise = null;
+  identifier;
   [IS_COLLECTION] = true;
   [SOURCE];
   [NOTIFY]() {
@@ -2615,6 +3029,7 @@ class IdentifierArray {
     this.modelName = options.type;
     this.store = options.store;
     this._manager = options.manager;
+    this.identifier = options.identifier || null;
     this[SOURCE] = options.identifiers;
     this[ARRAY_SIGNAL] = createSignal(this, 'length');
     const store = options.store;
@@ -2785,8 +3200,7 @@ class IdentifierArray {
           return false;
         }
         const original = target[index];
-        const newIdentifier = extractIdentifierFromRecord$1(value);
-        target[index] = newIdentifier;
+        const newIdentifier = extractIdentifierFromRecord$2(value);
         macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
           if (!test) {
             throw new Error(`Expected a record`);
@@ -2827,9 +3241,18 @@ class IdentifierArray {
         return Reflect.deleteProperty(target, prop);
       },
       getPrototypeOf() {
-        return IdentifierArray.prototype;
+        return Array.prototype;
       }
     });
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+      Object.defineProperty(this, '__SHOW_ME_THE_DATA_(debug mode only)__', {
+        enumerable: false,
+        configurable: true,
+        get() {
+          return proxy.slice();
+        }
+      });
+    }
     createArrayTags(proxy, _SIGNAL);
     this[NOTIFY] = this[NOTIFY].bind(proxy);
     return proxy;
@@ -2915,7 +3338,11 @@ const desc = {
   enumerable: true,
   configurable: false,
   get: function () {
-    return this;
+    // here to support computed chains
+    // and {{#each}}
+    if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_COMPUTED_CHAINS)) {
+      return this;
+    }
   }
 };
 compat(desc);
@@ -2966,7 +3393,7 @@ Collection.prototype.query = null;
 // Ensure instanceof works correctly
 // Object.setPrototypeOf(IdentifierArray.prototype, Array.prototype);
 
-function assertRecordPassedToHasMany(record) {
+function assertRecordPassedToHasMany$1(record) {
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
     if (!test) {
       throw new Error(`All elements of a hasMany relationship must be instances of Model, you passed $${typeof record}`);
@@ -2980,11 +3407,11 @@ function assertRecordPassedToHasMany(record) {
     }
   }()) : {};
 }
-function extractIdentifierFromRecord$1(record) {
+function extractIdentifierFromRecord$2(record) {
   if (!record) {
     return null;
   }
-  assertRecordPassedToHasMany(record);
+  assertRecordPassedToHasMany$1(record);
   return recordIdentifierFor(record);
 }
 
@@ -3059,6 +3486,12 @@ class RecordArrayManager {
     this._identifiers = new Map();
     this._set = new Map();
     this._visibilitySet = new Map();
+    this._subscription = this.store.notifications.subscribe('document', (identifier, type) => {
+      if (type === 'updated' && this._keyedArrays.has(identifier.lid)) {
+        const array = this._keyedArrays.get(identifier.lid);
+        this.dirtyArray(array, 0, true);
+      }
+    });
     this._subscription = this.store.notifications.subscribe('resource', (identifier, type) => {
       if (type === 'added') {
         this._visibilitySet.set(identifier, true);
@@ -3073,11 +3506,38 @@ class RecordArrayManager {
   }
   _syncArray(array) {
     const pending = this._pending.get(array);
-    if (!pending || this.isDestroying || this.isDestroyed) {
+    const isRequestArray = isCollection(array);
+    if (!isRequestArray && !pending || this.isDestroying || this.isDestroyed) {
       return;
     }
-    sync(array, pending, this._set.get(array));
-    this._pending.delete(array);
+
+    // first flush any staged changes
+    if (pending) {
+      sync(array, pending, this._set.get(array));
+      this._pending.delete(array);
+    }
+
+    // then pull new state if required
+    if (isRequestArray) {
+      const tag = array[ARRAY_SIGNAL];
+      if (tag.reason === 'cache-sync') {
+        tag.reason = null;
+        const doc = this.store.cache.peek(array.identifier);
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`Expected to find a document for ${array.identifier.lid} but found none`);
+          }
+        })(doc) : {};
+        const data = !('data' in doc) || !Array.isArray(doc.data) ? [] : doc.data;
+        // TODO technically we should destroy here if
+        // !('data' in doc) || !Array.isArray(doc.data)
+        // is true.
+        this.populateManagedArray(array, data, null);
+      }
+    }
+  }
+  mutate(mutation) {
+    this.store.cache.mutate(mutation);
   }
 
   /**
@@ -3113,9 +3573,13 @@ class RecordArrayManager {
     }
     return array;
   }
-  createArray(config) {
+  getCollection(config) {
+    if (config.identifier && this._keyedArrays.has(config.identifier.lid)) {
+      return this._keyedArrays.get(config.identifier.lid);
+    }
     const options = {
       type: config.type,
+      identifier: config.identifier || null,
       links: config.doc?.links || null,
       meta: config.doc?.meta || null,
       query: config.query || null,
@@ -3128,16 +3592,22 @@ class RecordArrayManager {
     const array = new Collection(options);
     this._managed.add(array);
     this._set.set(array, new Set(options.identifiers || []));
+    if (config.identifier) {
+      this._keyedArrays.set(config.identifier.lid, array);
+    }
     if (config.identifiers) {
       associate(this._identifiers, array, config.identifiers);
     }
     return array;
   }
-  dirtyArray(array, delta) {
+  dirtyArray(array, delta, shouldSyncFromCache) {
     if (array === FAKE_ARR) {
       return;
     }
     const tag = array[ARRAY_SIGNAL];
+    if (shouldSyncFromCache) {
+      tag.reason = 'cache-sync';
+    }
     if (!tag.shouldReset) {
       tag.shouldReset = true;
       addTransactionCB(array[NOTIFY]);
@@ -3196,13 +3666,18 @@ class RecordArrayManager {
   populateManagedArray(array, identifiers, payload) {
     this._pending.delete(array);
     const source = array[SOURCE];
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`The new state of the collection should not be using the same array reference as the original state.`);
+      }
+    })(source !== identifiers) : {};
     const old = source.slice();
     source.length = 0;
     fastPush(source, identifiers);
     this._set.set(array, new Set(identifiers));
     notifyArray(array);
-    array.meta = payload.meta || null;
-    array.links = payload.links || null;
+    array.meta = payload?.meta || null;
+    array.links = payload?.links || null;
     array.isLoaded = true;
     disassociate(this._identifiers, array, old);
     associate(this._identifiers, array, identifiers);
@@ -3216,7 +3691,7 @@ class RecordArrayManager {
           changes.delete(identifier);
         } else {
           changes.set(identifier, 'add');
-          this.dirtyArray(array, changes.size);
+          this.dirtyArray(array, changes.size, false);
         }
       });
     }
@@ -3230,7 +3705,7 @@ class RecordArrayManager {
           changes.delete(identifier);
         } else {
           changes.set(identifier, 'del');
-          this.dirtyArray(array, changes.size);
+          this.dirtyArray(array, changes.size, false);
         }
       });
     }
@@ -3335,6 +3810,9 @@ function sync(array, changes, arraySet) {
     */
   }
 }
+function isCollection(array) {
+  return array.identifier !== null;
+}
 
 /**
  * @module @ember-data/store
@@ -3595,6 +4073,118 @@ function constructResource(type, id, lid) {
  */
 // this import location is deprecated but breaks in 4.8 and older
 
+// @ts-expect-error adding to globalThis
+globalThis.setWarpDriveLogging = setLogging;
+
+// @ts-expect-error adding to globalThis
+globalThis.getWarpDriveRuntimeConfig = getRuntimeConfig;
+if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_METRIC_COUNTS)) {
+  if (getGlobalConfig().WarpDrive.debug.LOG_METRIC_COUNTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_METRIC_COUNTS) {
+    // @ts-expect-error adding to globalThis
+    // eslint-disable-next-line
+    globalThis.__WarpDriveMetricCountData = globalThis.__WarpDriveMetricCountData || {};
+
+    // @ts-expect-error adding to globalThis
+    globalThis.getWarpDriveMetricCounts = () => {
+      // @ts-expect-error
+      // eslint-disable-next-line
+      return structuredClone(globalThis.__WarpDriveMetricCountData);
+    };
+
+    // @ts-expect-error adding to globalThis
+    globalThis.resetWarpDriveMetricCounts = () => {
+      // @ts-expect-error
+      globalThis.__WarpDriveMetricCountData = {};
+    };
+    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS)) {
+      if (getGlobalConfig().WarpDrive.debug.__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS || globalThis.getWarpDriveRuntimeConfig().debug.__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS) {
+        // @ts-expect-error adding to globalThis
+        globalThis.__primitiveInstanceId = 0;
+        function interceptAndLog(klassName, methodName) {
+          const klass = globalThis[klassName];
+          if (methodName === 'constructor') {
+            const instantiationLabel = `new ${klassName}()`;
+            // @ts-expect-error
+            globalThis[klassName] = class extends klass {
+              // @ts-expect-error
+              constructor(...args) {
+                // eslint-disable-next-line
+                super(...args);
+                // @ts-expect-error
+
+                const instanceId = globalThis.__primitiveInstanceId++;
+                // @ts-expect-error
+                // eslint-disable-next-line
+                globalThis.__WarpDriveMetricCountData[instantiationLabel] =
+                // @ts-expect-error
+                // eslint-disable-next-line
+                (globalThis.__WarpDriveMetricCountData[instantiationLabel] || 0) + 1;
+                // @ts-expect-error
+                this.instanceName = `${klassName}:${instanceId} - ${new Error().stack?.split('\n')[2]}`;
+              }
+            };
+          } else {
+            // @ts-expect-error
+            // eslint-disable-next-line
+            const original = klass.prototype[methodName];
+            const logName = `${klassName}.${methodName}`;
+
+            // @ts-expect-error
+            klass.prototype[methodName] = function (...args) {
+              // @ts-expect-error
+              // eslint-disable-next-line
+              globalThis.__WarpDriveMetricCountData[logName] = (globalThis.__WarpDriveMetricCountData[logName] || 0) + 1;
+              // @ts-expect-error
+              const {
+                instanceName
+              } = this;
+              if (!instanceName) {
+                // @ts-expect-error
+                const instanceId = globalThis.__primitiveInstanceId++;
+                // @ts-expect-error
+                this.instanceName = `${klassName}.${methodName}:${instanceId} - ${new Error().stack?.split('\n')[2]}`;
+              }
+              const instanceLogName = `${logName} (${instanceName})`;
+              // @ts-expect-error
+              // eslint-disable-next-line
+              globalThis.__WarpDriveMetricCountData[instanceLogName] =
+              // @ts-expect-error
+              // eslint-disable-next-line
+              (globalThis.__WarpDriveMetricCountData[instanceLogName] || 0) + 1;
+              // eslint-disable-next-line
+              return original.apply(this, args);
+            };
+          }
+        }
+        interceptAndLog('Set', 'constructor');
+        interceptAndLog('Set', 'add');
+        interceptAndLog('Set', 'delete');
+        interceptAndLog('Set', 'has');
+        interceptAndLog('Set', 'set');
+        interceptAndLog('Set', 'get');
+        interceptAndLog('Map', 'constructor');
+        interceptAndLog('Map', 'set');
+        interceptAndLog('Map', 'delete');
+        interceptAndLog('Map', 'has');
+        interceptAndLog('Map', 'add');
+        interceptAndLog('Map', 'get');
+        interceptAndLog('WeakSet', 'constructor');
+        interceptAndLog('WeakSet', 'add');
+        interceptAndLog('WeakSet', 'delete');
+        interceptAndLog('WeakSet', 'has');
+        interceptAndLog('WeakSet', 'set');
+        interceptAndLog('WeakSet', 'get');
+        interceptAndLog('WeakMap', 'constructor');
+        interceptAndLog('WeakMap', 'set');
+        interceptAndLog('WeakMap', 'delete');
+        interceptAndLog('WeakMap', 'has');
+        interceptAndLog('WeakMap', 'add');
+        interceptAndLog('WeakMap', 'get');
+      }
+    }
+  }
+}
+
 // `AwaitedKeys` is needed here to resolve any promise types like `PromiseBelongsTo`.
 
 /**
@@ -3639,7 +4229,8 @@ const EmptyClass = class {
   // eslint-disable-next-line @typescript-eslint/no-useless-constructor
   constructor(args) {}
 };
-const BaseClass = macroCondition(dependencySatisfies('ember-source', '*')) ? macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_STORE_EXTENDS_EMBER_OBJECT) ? importSync('@ember/object') : EmptyClass : EmptyClass;
+const _BaseClass = macroCondition(dependencySatisfies('ember-source', '*')) ? macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_STORE_EXTENDS_EMBER_OBJECT) ? importSync('@ember/object') : EmptyClass : EmptyClass;
+const BaseClass = _BaseClass.default ? _BaseClass.default : _BaseClass;
 if (BaseClass !== EmptyClass) {
   deprecate(`The Store class extending from EmberObject is deprecated.
 Please remove usage of EmberObject APIs and mark your class as not requiring it.
@@ -3660,8 +4251,9 @@ const app = new EmberApp(defaults, {
     id: 'ember-data:deprecate-store-extends-ember-object',
     until: '6.0',
     for: 'ember-data',
+    url: 'https://deprecations.emberjs.com/id/ember-data-deprecate-store-extends-ember-object',
     since: {
-      available: '5.4',
+      available: '4.13',
       enabled: '5.4'
     }
   });
@@ -3721,12 +4313,9 @@ class Store extends BaseClass {
    * 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);
-   *   }
+   *   requestManager = new RequestManager()
+   *    .use([Fetch])
+   *    .useCache(CacheHandler);
    * }
    * ```
    *
@@ -3766,6 +4355,17 @@ class Store extends BaseClass {
 
   // Private
 
+  /**
+   * Async flush buffers notifications until flushed
+   * by finalization of a future configured by store.request
+   *
+   * This is useful for ensuring that notifications are delivered
+   * prior to the promise resolving but without risk of promise
+   * interleaving.
+   *
+   * @internal
+   */
+
   // DEBUG-only properties
 
   get isDestroying() {
@@ -3799,7 +4399,6 @@ class Store extends BaseClass {
     // private
     this._requestCache = new RequestStateService(this);
     this._instanceCache = new InstanceCache(this);
-    this._documentCache = new Map();
     this.isDestroying = false;
     this.isDestroyed = false;
   }
@@ -3839,6 +4438,16 @@ class Store extends BaseClass {
       this._cbs = null;
     }
   }
+
+  /**
+   * Executes the callback, ensurng that any work that calls
+   * store._schedule is executed after in the right order.
+   *
+   * When queues already exist, scheduled callbacks will
+   * join the existing queue.
+   *
+   * @internal
+   */
   _join(cb) {
     if (this._cbs) {
       cb();
@@ -3947,7 +4556,7 @@ class Store extends BaseClass {
     // the user has had the chance to set the prop.
     const opts = {
       store: this,
-      [EnableHydration]: true
+      [EnableHydration]: requestConfig[EnableHydration] ?? true
     };
     if (requestConfig.records) {
       const identifierCache = this.identifierCache;
@@ -3958,22 +4567,26 @@ class Store extends BaseClass {
         opts.disableTestWaiter = typeof requestConfig.disableTestWaiter === 'boolean' ? requestConfig.disableTestWaiter : true;
       }
     }
-    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_REQUESTS)) {
-      let options;
-      try {
-        options = JSON.parse(JSON.stringify(requestConfig));
-      } catch {
-        options = requestConfig;
+    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_REQUESTS)) {
+      if (getGlobalConfig().WarpDrive.debug.LOG_REQUESTS || globalThis.getWarpDriveRuntimeConfig().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);
       }
-      // 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 request = Object.assign({}, requestConfig, opts);
     const future = this.requestManager.request(request);
     future.onFinalize(() => {
-      if (macroCondition(getGlobalConfig().WarpDrive.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>'}`);
+      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_REQUESTS)) {
+        if (getGlobalConfig().WarpDrive.debug.LOG_REQUESTS || globalThis.getWarpDriveRuntimeConfig().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) {
@@ -4179,9 +4792,8 @@ class Store extends BaseClass {
     This will cause the record to be destroyed and freed up for garbage collection.
      Example
      ```javascript
-    store.findRecord('post', '1').then(function(post) {
-      store.unloadRecord(post);
-    });
+    const { content: { data: post } } = await store.request(findRecord({ type: 'post', id: '1' }));
+    store.unloadRecord(post);
     ```
      @method unloadRecord
     @public
@@ -4402,7 +5014,7 @@ class Store extends BaseClass {
      ```app/routes/post.js
     export default class PostRoute extends Route {
       model(params) {
-        return this.store.findRecord('post', params.post_id, { include: 'comments' });
+        return this.store.findRecord('post', params.post_id, { include: ['comments'] });
       }
     }
     ```
@@ -4424,13 +5036,13 @@ class Store extends BaseClass {
      In this case, the post's comments would then be available in your template as
     `model.comments`.
      Multiple relationships can be requested using an `include` parameter consisting of a
-    comma-separated list (without white-space) while nested relationships can be specified
+    list of relationship names, while nested relationships can be specified
     using a dot-separated sequence of relationship names. So to request both the post's
     comments and the authors of those comments the request would look like this:
      ```app/routes/post.js
     export default class PostRoute extends Route {
       model(params) {
-        return this.store.findRecord('post', params.post_id, { include: 'comments,comments.author' });
+        return this.store.findRecord('post', params.post_id, { include: ['comments','comments.author'] });
       }
     }
     ```
@@ -4951,18 +5563,18 @@ class Store extends BaseClass {
      ```app/routes/posts.js
     export default class PostsRoute extends Route {
       model() {
-        return this.store.findAll('post', { include: 'comments' });
+        return this.store.findAll('post', { include: ['comments'] });
       }
     }
     ```
     Multiple relationships can be requested using an `include` parameter consisting of a
-    comma-separated list (without white-space) while nested relationships can be specified
+    list or relationship names, while nested relationships can be specified
     using a dot-separated sequence of relationship names. So to request both the posts'
     comments and the authors of those comments the request would look like this:
      ```app/routes/posts.js
     export default class PostsRoute extends Route {
       model() {
-        return this.store.findAll('post', { include: 'comments,comments.author' });
+        return this.store.findAll('post', { include: ['comments','comments.author'] });
       }
     }
     ```
@@ -5233,16 +5845,6 @@ class Store extends BaseClass {
     if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyingStore(this, '_push');
     }
-    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_PAYLOADS)) {
-      try {
-        const data = JSON.parse(JSON.stringify(jsonApiDoc));
-        // eslint-disable-next-line no-console
-        console.log('EmberData | Payload - push', data);
-      } catch (e) {
-        // eslint-disable-next-line no-console
-        console.log('EmberData | Payload - push', jsonApiDoc);
-      }
-    }
     if (asyncFlush) {
       this._enableAsyncFlush = true;
     }
@@ -5373,10 +5975,10 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA
     })(this._schema) : {};
     deprecate(`Use \`store.schema\` instead of \`store.getSchemaDefinitionService()\``, false, {
       id: 'ember-data:schema-service-updates',
-      until: '5.0',
+      until: '6.0',
       for: 'ember-data',
       since: {
-        available: '5.4',
+        available: '4.13',
         enabled: '5.4'
       }
     });
@@ -5385,10 +5987,10 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA
   Store.prototype.registerSchemaDefinitionService = function (schema) {
     deprecate(`Use \`store.createSchemaService\` instead of \`store.registerSchemaDefinitionService()\``, false, {
       id: 'ember-data:schema-service-updates',
-      until: '5.0',
+      until: '6.0',
       for: 'ember-data',
       since: {
-        available: '5.4',
+        available: '4.13',
         enabled: '5.4'
       }
     });
@@ -5397,10 +5999,10 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA
   Store.prototype.registerSchema = function (schema) {
     deprecate(`Use \`store.createSchemaService\` instead of \`store.registerSchema()\``, false, {
       id: 'ember-data:schema-service-updates',
-      until: '5.0',
+      until: '6.0',
       for: 'ember-data',
       since: {
-        available: '5.4',
+        available: '4.13',
         enabled: '5.4'
       }
     });
@@ -5463,9 +6065,9 @@ function normalizeProperties(store, identifier, properties) {
           if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
             assertRecordsPassedToHasMany(properties[prop]);
           }
-          properties[prop] = extractIdentifiersFromRecords(properties[prop]);
+          properties[prop] = extractIdentifiersFromRecords$1(properties[prop]);
         } else if (field.kind === 'belongsTo') {
-          properties[prop] = extractIdentifierFromRecord(properties[prop]);
+          properties[prop] = extractIdentifierFromRecord$1(properties[prop]);
         }
       }
     }
@@ -5493,250 +6095,208 @@ function assertRecordsPassedToHasMany(records) {
     });
   }()) : {};
 }
-function extractIdentifiersFromRecords(records) {
-  return records.map(record => extractIdentifierFromRecord(record));
+function extractIdentifiersFromRecords$1(records) {
+  return records.map(record => extractIdentifierFromRecord$1(record));
 }
-function extractIdentifierFromRecord(recordOrPromiseRecord) {
+function extractIdentifierFromRecord$1(recordOrPromiseRecord) {
   if (!recordOrPromiseRecord) {
     return null;
   }
   const extract = recordIdentifierFor;
   return extract(recordOrPromiseRecord);
 }
+const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);
+function calcShouldFetch(store, request, hasCachedValue, identifier) {
+  const {
+    cacheOptions
+  } = request;
+  return request.op && MUTATION_OPS.has(request.op) || cacheOptions?.reload || !hasCachedValue || (store.lifetimes && identifier ? store.lifetimes.isHardExpired(identifier, store) : false);
+}
+function calcShouldBackgroundFetch(store, request, willFetch, identifier) {
+  const {
+    cacheOptions
+  } = request;
+  return cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier, store) : false);
+}
+function isMutation(request) {
+  return Boolean(request.op && MUTATION_OPS.has(request.op));
+}
+function isCacheAffecting(document) {
+  if (!isMutation(document.request)) {
+    return true;
+  }
+  // a mutation combined with a 204 has no cache impact when no known records were involved
+  // a createRecord with a 201 with an empty response and no known records should similarly
+  // have no cache impact
+
+  if (document.request.op === 'createRecord' && document.response?.status === 201) {
+    return document.content ? Object.keys(document.content).length > 0 : false;
+  }
+  return document.response?.status !== 204;
+}
+function isAggregateError(error) {
+  return error instanceof AggregateError || error.name === 'AggregateError' && Array.isArray(error.errors);
+}
+// TODO @runspired, consider if we should deep freeze errors (potentially only in debug) vs cloning them
+function cloneError(error) {
+  const isAggregate = isAggregateError(error);
+  const cloned = isAggregate ? new AggregateError(structuredClone(error.errors), error.message) : new Error(error.message);
+  cloned.stack = error.stack;
+  cloned.error = error.error;
+
+  // copy over enumerable properties
+  Object.assign(cloned, error);
+  return cloned;
+}
+function getPriority(identifier, deduped, priority) {
+  if (identifier) {
+    const existing = deduped.get(identifier);
+    if (existing) {
+      return existing.priority;
+    }
+  }
+  return priority;
+}
 
 /**
  * @module @ember-data/store
  */
-function urlFromLink(link) {
-  if (typeof link === 'string') return link;
-  return link.href;
-}
 
 /**
- * A Document is a class that wraps the response content from a request to the API
- * returned by `Cache.put` or `Cache.peek`, converting resource-identifiers into
- * record instances.
+ * A CacheHandler that adds support for using an EmberData Cache with a RequestManager.
  *
- * It is not directly instantiated by the user, and its properties should not
- * be directly modified. Whether individual properties are mutable or not is
- * determined by the record instance itself.
+ * This handler will only run when a request has supplied a `store` instance. Requests
+ * issued by the store via `store.request()` will automatically have the `store` instance
+ * attached to the request.
  *
- * @public
- * @class Document
+ * ```ts
+ * requestManager.request({
+ *   store: store,
+ *   url: '/api/posts',
+ *   method: 'GET'
+ * });
+ * ```
+ *
+ * When this handler elects to handle a request, it will return the raw `StructuredDocument`
+ * unless the request has `[EnableHydration]` set to `true`. In this case, the handler will
+ * return a `Document` instance that will automatically update the UI when the cache is updated
+ * in the future and will hydrate any identifiers in the StructuredDocument into Record instances.
+ *
+ * When issuing a request via the store, [EnableHydration] is automatically set to `true`. This
+ * means that if desired you can issue requests that utilize the cache without needing to also
+ * utilize Record instances if desired.
+ *
+ * Said differently, you could elect to issue all requests via a RequestManager, without ever using
+ * the store directly, by setting [EnableHydration] to `true` and providing a store instance. Not
+ * necessarily the most useful thing, but the decoupled nature of the RequestManager and incremental-feature
+ * approach of EmberData allows for this flexibility.
+ *
+ * ```ts
+ * import { EnableHydration } from '@warp-drive/core-types/request';
+ *
+ * requestManager.request({
+ *   store: store,
+ *   url: '/api/posts',
+ *   method: 'GET',
+ *   [EnableHydration]: true
+ * });
+ *
+ * @typedoc
  */
-class Document {
-  /**
-   * The links object for this document, if any
-   *
-   * e.g.
-   *
-   * ```
-   * {
-   *   self: '/articles?page[number]=3',
-   * }
-   * ```
-   *
-   * @property links
-   * @type {object|undefined} - a links object
-   * @public
-   */
-
-  /**
-   * The primary data for this document, if any.
-   *
-   * If this document has no primary data (e.g. because it is an error document)
-   * this property will be `undefined`.
-   *
-   * For collections this will be an array of record instances,
-   * for single resource requests it will be a single record instance or null.
-   *
-   * @property data
-   * @public
-   * @type {object|Array<object>|null|undefined} - a data object
-   */
-
-  /**
-   * The errors returned by the API for this request, if any
-   *
-   * @property errors
-   * @public
-   * @type {object|undefined} - an errors object
-   */
-
-  /**
-   * The meta object for this document, if any
-   *
-   * @property meta
-   * @public
-   * @type {object|undefined} - a meta object
-   */
+const CacheHandler = {
+  request(context, next) {
+    // if we have no cache or no cache-key skip cache handling
+    if (!context.request.store || context.request.cacheOptions?.[SkipCache]) {
+      return next(context.request);
+    }
+    const {
+      store
+    } = context.request;
+    const identifier = store.identifierCache.getOrCreateDocumentIdentifier(context.request);
+    if (identifier) {
+      context.setIdentifier(identifier);
+    }
 
-  /**
-   * The identifier associated with this document, if any
-   *
-   * @property identifier
-   * @public
-   * @type {StableDocumentIdentifier|null}
-   */
+    // used to dedupe existing requests that match
+    const DEDUPE = store.requestManager._deduped;
+    const activeRequest = identifier && DEDUPE.get(identifier);
+    const peeked = identifier ? store.cache.peekRequest(identifier) : null;
 
-  #store;
-  constructor(store, identifier) {
-    this.#store = store;
-    this.identifier = identifier;
-  }
-  async #request(link, options) {
-    const href = this.links?.[link];
-    if (!href) {
-      return null;
+    // determine if we should skip cache
+    if (calcShouldFetch(store, context.request, !!peeked, identifier)) {
+      if (activeRequest) {
+        activeRequest.priority = {
+          blocking: true
+        };
+        return activeRequest.promise;
+      }
+      let promise = fetchContentAndHydrate(next, context, identifier, {
+        blocking: true
+      });
+      if (identifier) {
+        promise = promise.finally(() => {
+          DEDUPE.delete(identifier);
+          store.notifications.notify(identifier, 'state');
+        });
+        DEDUPE.set(identifier, {
+          priority: {
+            blocking: true
+          },
+          promise
+        });
+        store.notifications.notify(identifier, 'state');
+      }
+      return promise;
     }
-    options.method = options.method || 'GET';
-    Object.assign(options, {
-      url: urlFromLink(href)
-    });
-    const response = await this.#store.request(options);
-    return response.content;
-  }
 
-  /**
-   * Fetches the related link for this document, returning a promise that resolves
-   * with the document when the request completes. If no related link is present,
-   * will fallback to the self link if present
-   *
-   * @method fetch
-   * @public
-   * @param {object} options
-   * @return Promise<Document>
-   */
-  fetch(options = {}) {
+    // if we have not skipped cache, determine if we should update behind the scenes
+    if (calcShouldBackgroundFetch(store, context.request, false, identifier)) {
+      let promise = activeRequest?.promise || fetchContentAndHydrate(next, context, identifier, {
+        blocking: false
+      });
+      if (identifier && !activeRequest) {
+        promise = promise.finally(() => {
+          DEDUPE.delete(identifier);
+          store.notifications.notify(identifier, 'state');
+        });
+        DEDUPE.set(identifier, {
+          priority: {
+            blocking: false
+          },
+          promise
+        });
+        store.notifications.notify(identifier, 'state');
+      }
+      store.requestManager._pending.set(context.id, promise);
+    }
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
-        throw new Error(`No self or related link`);
+        throw new Error(`Expected a peeked request to be present`);
       }
-    })(this.links?.related || this.links?.self) : {};
-    options.cacheOptions = options.cacheOptions || {};
-    options.cacheOptions.key = this.identifier?.lid;
-    return this.#request(this.links.related ? 'related' : 'self', options);
-  }
-
-  /**
-   * Fetches the next link for this document, returning a promise that resolves
-   * with the new document when the request completes, or null  if there is no
-   * next link.
-   *
-   * @method next
-   * @public
-   * @param {object} options
-   * @return Promise<Document | null>
-   */
-  next(options = {}) {
-    return this.#request('next', options);
-  }
-
-  /**
-   * Fetches the prev link for this document, returning a promise that resolves
-   * with the new document when the request completes, or null if there is no
-   * prev link.
-   *
-   * @method prev
-   * @public
-   * @param {object} options
-   * @return Promise<Document | null>
-   */
-  prev(options = {}) {
-    return this.#request('prev', options);
-  }
-
-  /**
-   * Fetches the first link for this document, returning a promise that resolves
-   * with the new document when the request completes, or null if there is no
-   * first link.
-   *
-   * @method first
-   * @public
-   * @param {object} options
-   * @return Promise<Document | null>
-   */
-  first(options = {}) {
-    return this.#request('first', options);
-  }
-
-  /**
-   * Fetches the last link for this document, returning a promise that resolves
-   * with the new document when the request completes, or null if there is no
-   * last link.
-   *
-   * @method last
-   * @public
-   * @param {object} options
-   * @return Promise<Document | null>
-   */
-  last(options = {}) {
-    return this.#request('last', options);
-  }
-
-  /**
-   * Implemented for `JSON.stringify` support.
-   *
-   * Returns the JSON representation of the document wrapper.
-   *
-   * This is a shallow serialization, it does not deeply serialize
-   * the document's contents, leaving that to the individual record
-   * instances to determine how to do, if at all.
-   *
-   * @method toJSON
-   * @public
-   * @return
-   */
-  toJSON() {
-    const data = {};
-    data.identifier = this.identifier;
-    if (this.data !== undefined) {
-      data.data = this.data;
-    }
-    if (this.links !== undefined) {
-      data.links = this.links;
-    }
-    if (this.errors !== undefined) {
-      data.errors = this.errors;
-    }
-    if (this.meta !== undefined) {
-      data.meta = this.meta;
+    })(peeked) : {};
+    const shouldHydrate = context.request[EnableHydration] || false;
+    context.setResponse(peeked.response);
+    if ('error' in peeked) {
+      const content = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
+        shouldHydrate,
+        identifier
+      }, peeked.content) : peeked.content;
+      const newError = cloneError(peeked);
+      newError.content = content;
+      throw newError;
     }
-    return data;
+    const result = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
+      shouldHydrate,
+      identifier
+    }, peeked.content) : peeked.content;
+    return result;
   }
-}
-defineSignal(Document.prototype, 'data');
-defineSignal(Document.prototype, 'links');
-defineSignal(Document.prototype, 'errors');
-defineSignal(Document.prototype, 'meta');
-
-/**
- * @module @ember-data/store
- */
-
-/**
- * A service which an application may provide to the store via
- * the store's `lifetimes` property to configure the behavior
- * of the CacheHandler.
- *
- * The default behavior for request lifetimes is to never expire
- * unless manually refreshed via `cacheOptions.reload` or `cacheOptions.backgroundReload`.
- *
- * Implementing this service allows you to programatically define
- * when a request should be considered expired.
- *
- * @class <Interface> CachePolicy
- * @public
- */
-const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);
-function isErrorDocument(document) {
-  return 'errors' in document;
-}
-function maybeUpdateUiObjects(store, request, options, document, isFromCache) {
+};
+function maybeUpdateUiObjects(store, request, options, document) {
   const {
     identifier
   } = options;
-  if (!document) {
+  if (!document || !options.shouldHydrate) {
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
         throw new Error(`The CacheHandler expected response content but none was found`);
@@ -5744,113 +6304,105 @@ function maybeUpdateUiObjects(store, request, options, document, isFromCache) {
     })(!options.shouldHydrate) : {};
     return document;
   }
-  if (isErrorDocument(document)) {
-    if (!identifier && !options.shouldHydrate) {
-      return document;
-    }
-    let doc;
-    if (identifier) {
-      doc = store._documentCache.get(identifier);
-    }
-    if (!doc) {
-      doc = new Document(store, identifier);
-      copyDocumentProperties(doc, document);
-      if (identifier) {
-        store._documentCache.set(identifier, doc);
-      }
-    } else if (!isFromCache) {
-      doc.data = undefined;
-      copyDocumentProperties(doc, document);
-    }
-    return options.shouldHydrate ? doc : document;
+  if (identifier) {
+    return store._instanceCache.getDocument(identifier);
   }
-  if (Array.isArray(document.data)) {
-    const {
-      recordArrayManager
-    } = store;
-    if (!identifier) {
-      if (!options.shouldHydrate) {
-        return document;
-      }
-      const data = recordArrayManager.createArray({
-        type: request.url,
-        identifiers: document.data,
-        doc: document,
-        query: request
-      });
-      const doc = new Document(store, null);
-      doc.data = data;
-      doc.meta = document.meta;
-      doc.links = document.links;
-      return doc;
-    }
-    let managed = recordArrayManager._keyedArrays.get(identifier.lid);
-    if (!managed) {
-      managed = recordArrayManager.createArray({
-        type: identifier.lid,
-        identifiers: document.data,
-        doc: document
-      });
-      recordArrayManager._keyedArrays.set(identifier.lid, managed);
-      const doc = new Document(store, identifier);
-      doc.data = managed;
-      doc.meta = document.meta;
-      doc.links = document.links;
-      store._documentCache.set(identifier, doc);
-      return options.shouldHydrate ? doc : document;
-    } else {
-      const doc = store._documentCache.get(identifier);
-      if (!isFromCache) {
-        recordArrayManager.populateManagedArray(managed, document.data, document);
-        doc.data = managed;
-        doc.meta = document.meta;
-        doc.links = document.links;
-      }
-      return options.shouldHydrate ? doc : document;
+
+  // if we don't have an identifier, we give the document
+  // its own local cache
+  return new ReactiveDocument(store, null, {
+    request,
+    document
+  });
+}
+function updateCacheForSuccess(store, request, options, document) {
+  let response = null;
+  if (isMutation(request)) {
+    const record = request.data?.record || request.records?.[0];
+    if (record) {
+      response = store.cache.didCommit(record, document);
+
+      // a mutation combined with a 204 has no cache impact when no known records were involved
+      // a createRecord with a 201 with an empty response and no known records should similarly
+      // have no cache impact
+    } else if (isCacheAffecting(document)) {
+      response = store.cache.put(document);
     }
   } else {
-    if (!identifier && !options.shouldHydrate) {
-      return document;
-    }
-    const data = document.data ? store.peekRecord(document.data) : null;
-    let doc;
-    if (identifier) {
-      doc = store._documentCache.get(identifier);
-    }
-    if (!doc) {
-      doc = new Document(store, identifier);
-      doc.data = data;
-      copyDocumentProperties(doc, document);
-      if (identifier) {
-        store._documentCache.set(identifier, doc);
-      }
-    } else if (!isFromCache) {
-      doc.data = data;
-      copyDocumentProperties(doc, document);
-    }
-    return options.shouldHydrate ? doc : document;
+    response = store.cache.put(document);
   }
+  return maybeUpdateUiObjects(store, request, options, response);
 }
-function calcShouldFetch(store, request, hasCachedValue, identifier) {
+function handleFetchSuccess(store, context, options, document) {
   const {
-    cacheOptions
-  } = request;
-  return request.op && MUTATION_OPS.has(request.op) || cacheOptions?.reload || !hasCachedValue || (store.lifetimes && identifier ? store.lifetimes.isHardExpired(identifier, store) : false);
+    request
+  } = context;
+  store.requestManager._pending.delete(context.id);
+  store._enableAsyncFlush = true;
+  let response;
+  store._join(() => {
+    response = updateCacheForSuccess(store, request, options, document);
+  });
+  store._enableAsyncFlush = null;
+  if (store.lifetimes?.didRequest) {
+    store.lifetimes.didRequest(context.request, document.response, options.identifier, store);
+  }
+  const finalPriority = getPriority(options.identifier, store.requestManager._deduped, options.priority);
+  if (finalPriority.blocking) {
+    return response;
+  } else {
+    store.notifications._flush();
+  }
 }
-function calcShouldBackgroundFetch(store, request, willFetch, identifier) {
-  const {
-    cacheOptions
-  } = request;
-  return cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier, store) : false);
+function updateCacheForError(store, context, options, error) {
+  let response;
+  if (isMutation(context.request)) {
+    // TODO similar to didCommit we should spec this to be similar to cache.put for handling full response
+    // currently we let the response remain undefiend.
+    const errors = error && error.content && typeof error.content === 'object' && 'errors' in error.content && Array.isArray(error.content.errors) ? error.content.errors : undefined;
+    const record = context.request.data?.record || context.request.records?.[0];
+    store.cache.commitWasRejected(record, errors);
+  } else {
+    response = store.cache.put(error);
+    return maybeUpdateUiObjects(store, context.request, options, response);
+  }
 }
-function isMutation(request) {
-  return Boolean(request.op && MUTATION_OPS.has(request.op));
+function handleFetchError(store, context, options, error) {
+  store.requestManager._pending.delete(context.id);
+  if (context.request.signal?.aborted) {
+    throw error;
+  }
+  store._enableAsyncFlush = true;
+  let response;
+  store._join(() => {
+    response = updateCacheForError(store, context, options, error);
+  });
+  store._enableAsyncFlush = null;
+  if (options.identifier && store.lifetimes?.didRequest) {
+    store.lifetimes.didRequest(context.request, error.response, options.identifier, store);
+  }
+  if (isMutation(context.request)) {
+    throw error;
+  }
+  const finalPriority = getPriority(options.identifier, store.requestManager._deduped, options.priority);
+  if (finalPriority.blocking) {
+    const newError = cloneError(error);
+    newError.content = response;
+    throw newError;
+  } else {
+    store.notifications._flush();
+  }
 }
-function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBackgroundFetch) {
+function fetchContentAndHydrate(next, context, identifier, priority) {
   const {
     store
   } = context.request;
   const shouldHydrate = context.request[EnableHydration] || false;
+  const options = {
+    shouldHydrate,
+    identifier,
+    priority
+  };
   let isMut = false;
   if (isMutation(context.request)) {
     isMut = true;
@@ -5867,80 +6419,11 @@ function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBa
   }
   if (store.lifetimes?.willRequest) {
     store.lifetimes.willRequest(context.request, identifier, store);
-  }
-  const promise = next(context.request).then(document => {
-    store.requestManager._pending.delete(context.id);
-    store._enableAsyncFlush = true;
-    let response;
-    store._join(() => {
-      if (isMutation(context.request)) {
-        const record = context.request.data?.record || context.request.records?.[0];
-        if (record) {
-          response = store.cache.didCommit(record, document);
-
-          // a mutation combined with a 204 has no cache impact when no known records were involved
-          // a createRecord with a 201 with an empty response and no known records should similarly
-          // have no cache impact
-        } else if (isCacheAffecting(document)) {
-          response = store.cache.put(document);
-        }
-      } else {
-        response = store.cache.put(document);
-      }
-      response = maybeUpdateUiObjects(store, context.request, {
-        shouldHydrate,
-        shouldFetch,
-        shouldBackgroundFetch,
-        identifier
-      }, response, false);
-    });
-    store._enableAsyncFlush = null;
-    if (store.lifetimes?.didRequest) {
-      store.lifetimes.didRequest(context.request, document.response, identifier, store);
-    }
-    if (shouldFetch) {
-      return response;
-    } else if (shouldBackgroundFetch) {
-      store.notifications._flush();
-    }
-  }, error => {
-    store.requestManager._pending.delete(context.id);
-    if (context.request.signal?.aborted) {
-      throw error;
-    }
-    store.requestManager._pending.delete(context.id);
-    store._enableAsyncFlush = true;
-    let response;
-    store._join(() => {
-      if (isMutation(context.request)) {
-        // TODO similar to didCommit we should spec this to be similar to cache.put for handling full response
-        // currently we let the response remain undefiend.
-        const errors = error && error.content && typeof error.content === 'object' && 'errors' in error.content && Array.isArray(error.content.errors) ? error.content.errors : undefined;
-        const record = context.request.data?.record || context.request.records?.[0];
-        store.cache.commitWasRejected(record, errors);
-        // re-throw the original error to preserve `errors` property.
-        throw error;
-      } else {
-        response = store.cache.put(error);
-        response = maybeUpdateUiObjects(store, context.request, {
-          shouldHydrate,
-          shouldFetch,
-          shouldBackgroundFetch,
-          identifier
-        }, response, false);
-      }
-    });
-    store._enableAsyncFlush = null;
-    if (identifier && store.lifetimes?.didRequest) {
-      store.lifetimes.didRequest(context.request, error.response, identifier, store);
-    }
-    if (!shouldBackgroundFetch) {
-      const newError = cloneError(error);
-      newError.content = response;
-      throw newError;
-    } else {
-      store.notifications._flush();
-    }
+  }
+  const promise = next(context.request).then(document => {
+    return handleFetchSuccess(store, context, options, document);
+  }, error => {
+    return handleFetchError(store, context, options, error);
   });
   if (!isMut) {
     return promise;
@@ -5962,129 +6445,475 @@ function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBa
     }]
   });
 }
-function isAggregateError(error) {
-  return error instanceof AggregateError || error.name === 'AggregateError' && Array.isArray(error.errors);
-}
-// TODO @runspired, consider if we should deep freeze errors (potentially only in debug) vs cloning them
-function cloneError(error) {
-  const isAggregate = isAggregateError(error);
-  const cloned = isAggregate ? new AggregateError(structuredClone(error.errors), error.message) : new Error(error.message);
-  cloned.stack = error.stack;
-  cloned.error = error.error;
-
-  // copy over enumerable properties
-  Object.assign(cloned, error);
-  return cloned;
-}
 
 /**
- * A CacheHandler that adds support for using an EmberData Cache with a RequestManager.
- *
- * This handler will only run when a request has supplied a `store` instance. Requests
- * issued by the store via `store.request()` will automatically have the `store` instance
- * attached to the request.
- *
- * ```ts
- * requestManager.request({
- *   store: store,
- *   url: '/api/posts',
- *   method: 'GET'
- * });
- * ```
- *
- * When this handler elects to handle a request, it will return the raw `StructuredDocument`
- * unless the request has `[EnableHydration]` set to `true`. In this case, the handler will
- * return a `Document` instance that will automatically update the UI when the cache is updated
- * in the future and will hydrate any identifiers in the StructuredDocument into Record instances.
- *
- * When issuing a request via the store, [EnableHydration] is automatically set to `true`. This
- * means that if desired you can issue requests that utilize the cache without needing to also
- * utilize Record instances if desired.
- *
- * Said differently, you could elect to issue all requests via a RequestManager, without ever using
- * the store directly, by setting [EnableHydration] to `true` and providing a store instance. Not
- * necessarily the most useful thing, but the decoupled nature of the RequestManager and incremental-feature
- * approach of EmberData allows for this flexibility.
- *
- * ```ts
- * import { EnableHydration } from '@warp-drive/core-types/request';
- *
- * requestManager.request({
- *   store: store,
- *   url: '/api/posts',
- *   method: 'GET',
- *   [EnableHydration]: true
- * });
- *
- * @typedoc
- */
-const CacheHandler = {
-  request(context, next) {
-    // if we have no cache or no cache-key skip cache handling
-    if (!context.request.store || context.request.cacheOptions?.[SkipCache]) {
-      return next(context.request);
-    }
-    const {
-      store
-    } = context.request;
-    const identifier = store.identifierCache.getOrCreateDocumentIdentifier(context.request);
-    const peeked = identifier ? store.cache.peekRequest(identifier) : null;
+  @module @ember-data/store
+*/
+/**
+  A `ManyArray` is a `MutableArray` that represents the contents of a has-many
+  relationship.
 
-    // determine if we should skip cache
-    if (calcShouldFetch(store, context.request, !!peeked, identifier)) {
-      return fetchContentAndHydrate(next, context, identifier, true, false);
+  The `ManyArray` is instantiated lazily the first time the relationship is
+  requested.
+
+  This class is not intended to be directly instantiated by consuming applications.
+
+  ### Inverses
+
+  Often, the relationships in Ember Data applications will have
+  an inverse. For example, imagine the following models are
+  defined:
+
+  ```app/models/post.js
+  import Model, { hasMany } from '@ember-data/model';
+
+  export default class PostModel extends Model {
+    @hasMany('comment') comments;
+  }
+  ```
+
+  ```app/models/comment.js
+  import Model, { belongsTo } from '@ember-data/model';
+
+  export default class CommentModel extends Model {
+    @belongsTo('post') post;
+  }
+  ```
+
+  If you created a new instance of `Post` and added
+  a `Comment` record to its `comments` has-many
+  relationship, you would expect the comment's `post`
+  property to be set to the post that contained
+  the has-many.
+
+  We call the record to which a relationship belongs-to the
+  relationship's _owner_.
+
+  @class ManyArray
+  @public
+*/
+class RelatedCollection extends IdentifierArray {
+  /**
+    The loading state of this array
+     @property {Boolean} isLoaded
+    @public
+    */
+
+  /**
+    `true` if the relationship is polymorphic, `false` otherwise.
+     @property {Boolean} isPolymorphic
+    @private
+    */
+
+  /**
+    Metadata associated with the request for async hasMany relationships.
+     Example
+     Given that the server returns the following JSON payload when fetching a
+    hasMany relationship:
+     ```js
+    {
+      "comments": [{
+        "id": 1,
+        "comment": "This is the first comment",
+      }, {
+    // ...
+      }],
+       "meta": {
+        "page": 1,
+        "total": 5
+      }
     }
+    ```
+     You can then access the meta data via the `meta` property:
+     ```js
+    let comments = await post.comments;
+    let meta = comments.meta;
+     // meta.page => 1
+    // meta.total => 5
+    ```
+     @property {Object | null} meta
+    @public
+    */
 
-    // if we have not skipped cache, determine if we should update behind the scenes
-    if (calcShouldBackgroundFetch(store, context.request, false, identifier)) {
-      const promise = fetchContentAndHydrate(next, context, identifier, false, true);
-      store.requestManager._pending.set(context.id, promise);
+  /**
+     * Retrieve the links for this relationship
+     *
+     @property {Object | null} links
+     @public
+     */
+
+  constructor(options) {
+    super(options);
+    this.isLoaded = options.isLoaded || false;
+    this.isAsync = options.isAsync || false;
+    this.isPolymorphic = options.isPolymorphic || false;
+    this.identifier = options.identifier;
+    this.key = options.key;
+  }
+  [MUTATE](target, receiver, prop, args, _SIGNAL) {
+    switch (prop) {
+      case 'length 0':
+        {
+          Reflect.set(target, 'length', 0);
+          mutateReplaceRelatedRecords(this, [], _SIGNAL);
+          return true;
+        }
+      case 'replace cell':
+        {
+          const [index, prior, value] = args;
+          target[index] = value;
+          mutateReplaceRelatedRecord(this, {
+            value,
+            prior,
+            index
+          }, _SIGNAL);
+          return true;
+        }
+      case 'push':
+        {
+          const newValues = extractIdentifiersFromRecords(args);
+          assertNoDuplicates(this, target, currentState => currentState.push(...newValues), `Cannot push duplicates to a hasMany's state.`);
+          if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
+            // dedupe
+            const seen = new Set(target);
+            const unique = new Set();
+            args.forEach(item => {
+              const identifier = recordIdentifierFor(item);
+              if (!seen.has(identifier)) {
+                seen.add(identifier);
+                unique.add(item);
+              }
+            });
+            const newArgs = Array.from(unique);
+            const result = Reflect.apply(target[prop], receiver, newArgs);
+            if (newArgs.length) {
+              mutateAddToRelatedRecords(this, {
+                value: extractIdentifiersFromRecords(newArgs)
+              }, _SIGNAL);
+            }
+            return result;
+          }
+
+          // else, no dedupe, error on duplicates
+          const result = Reflect.apply(target[prop], receiver, args);
+          if (newValues.length) {
+            mutateAddToRelatedRecords(this, {
+              value: newValues
+            }, _SIGNAL);
+          }
+          return result;
+        }
+      case 'pop':
+        {
+          const result = Reflect.apply(target[prop], receiver, args);
+          if (result) {
+            mutateRemoveFromRelatedRecords(this, {
+              value: recordIdentifierFor(result)
+            }, _SIGNAL);
+          }
+          return result;
+        }
+      case 'unshift':
+        {
+          const newValues = extractIdentifiersFromRecords(args);
+          assertNoDuplicates(this, target, currentState => currentState.unshift(...newValues), `Cannot unshift duplicates to a hasMany's state.`);
+          if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
+            // dedupe
+            const seen = new Set(target);
+            const unique = new Set();
+            args.forEach(item => {
+              const identifier = recordIdentifierFor(item);
+              if (!seen.has(identifier)) {
+                seen.add(identifier);
+                unique.add(item);
+              }
+            });
+            const newArgs = Array.from(unique);
+            const result = Reflect.apply(target[prop], receiver, newArgs);
+            if (newArgs.length) {
+              mutateAddToRelatedRecords(this, {
+                value: extractIdentifiersFromRecords(newArgs),
+                index: 0
+              }, _SIGNAL);
+            }
+            return result;
+          }
+
+          // else, no dedupe, error on duplicates
+          const result = Reflect.apply(target[prop], receiver, args);
+          if (newValues.length) {
+            mutateAddToRelatedRecords(this, {
+              value: newValues,
+              index: 0
+            }, _SIGNAL);
+          }
+          return result;
+        }
+      case 'shift':
+        {
+          const result = Reflect.apply(target[prop], receiver, args);
+          if (result) {
+            mutateRemoveFromRelatedRecords(this, {
+              value: recordIdentifierFor(result),
+              index: 0
+            }, _SIGNAL);
+          }
+          return result;
+        }
+      case 'sort':
+        {
+          const result = Reflect.apply(target[prop], receiver, args);
+          mutateSortRelatedRecords(this, result.map(recordIdentifierFor), _SIGNAL);
+          return result;
+        }
+      case 'splice':
+        {
+          const [start, deleteCount, ...adds] = args;
+
+          // detect a full replace
+          if (start === 0 && deleteCount === this[SOURCE].length) {
+            const newValues = extractIdentifiersFromRecords(adds);
+            assertNoDuplicates(this, target, currentState => currentState.splice(start, deleteCount, ...newValues), `Cannot replace a hasMany's state with a new state that contains duplicates.`);
+            if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
+              // dedupe
+              const current = new Set(adds);
+              const unique = Array.from(current);
+              const newArgs = [start, deleteCount].concat(unique);
+              const result = Reflect.apply(target[prop], receiver, newArgs);
+              mutateReplaceRelatedRecords(this, extractIdentifiersFromRecords(unique), _SIGNAL);
+              return result;
+            }
+
+            // else, no dedupe, error on duplicates
+            const result = Reflect.apply(target[prop], receiver, args);
+            mutateReplaceRelatedRecords(this, newValues, _SIGNAL);
+            return result;
+          }
+          const newValues = extractIdentifiersFromRecords(adds);
+          assertNoDuplicates(this, target, currentState => currentState.splice(start, deleteCount, ...newValues), `Cannot splice a hasMany's state with a new state that contains duplicates.`);
+          if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
+            // dedupe
+            const currentState = target.slice();
+            currentState.splice(start, deleteCount);
+            const seen = new Set(currentState);
+            const unique = [];
+            adds.forEach(item => {
+              const identifier = recordIdentifierFor(item);
+              if (!seen.has(identifier)) {
+                seen.add(identifier);
+                unique.push(item);
+              }
+            });
+            const newArgs = [start, deleteCount, ...unique];
+            const result = Reflect.apply(target[prop], receiver, newArgs);
+            if (deleteCount > 0) {
+              mutateRemoveFromRelatedRecords(this, {
+                value: result.map(recordIdentifierFor),
+                index: start
+              }, _SIGNAL);
+            }
+            if (unique.length > 0) {
+              mutateAddToRelatedRecords(this, {
+                value: extractIdentifiersFromRecords(unique),
+                index: start
+              }, _SIGNAL);
+            }
+            return result;
+          }
+
+          // else, no dedupe, error on duplicates
+          const result = Reflect.apply(target[prop], receiver, args);
+          if (deleteCount > 0) {
+            mutateRemoveFromRelatedRecords(this, {
+              value: result.map(recordIdentifierFor),
+              index: start
+            }, _SIGNAL);
+          }
+          if (newValues.length > 0) {
+            mutateAddToRelatedRecords(this, {
+              value: newValues,
+              index: start
+            }, _SIGNAL);
+          }
+          return result;
+        }
+      default:
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`unable to convert ${prop} into a transaction that updates the cache state for this record array`);
+          }
+        })() : {};
     }
+  }
+  notify() {
+    const signal = this[ARRAY_SIGNAL];
+    signal.shouldReset = true;
+    notifyArray(this);
+  }
+
+  /**
+    Reloads all of the records in the manyArray. If the manyArray
+    holds a relationship that was originally fetched using a links url
+    EmberData will revisit the original links url to repopulate the
+    relationship.
+     If the ManyArray holds the result of a `store.query()` reload will
+    re-run the original query.
+     Example
+     ```javascript
+    let user = store.peekRecord('user', '1')
+    await login(user);
+     let permissions = await user.permissions;
+    await permissions.reload();
+    ```
+     @method reload
+    @public
+  */
+  reload(options) {
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
-        throw new Error(`Expected a peeked request to be present`);
+        throw new Error(`Expected the manager for ManyArray to implement reloadHasMany`);
       }
-    })(peeked) : {};
-    const shouldHydrate = context.request[EnableHydration] || false;
-    context.setResponse(peeked.response);
-    if ('error' in peeked) {
-      const content = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
-        shouldHydrate,
-        identifier
-      }, peeked.content, true) : peeked.content;
-      const newError = cloneError(peeked);
-      newError.content = content;
-      throw newError;
-    }
-    const result = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
-      shouldHydrate,
-      identifier
-    }, peeked.content, true) : peeked.content;
-    return result;
+    })(typeof this._manager.reloadHasMany === 'function') : {};
+    // TODO this is odd, we don't ask the store for anything else like this?
+    return this._manager.reloadHasMany(this.key, options);
   }
-};
-function copyDocumentProperties(target, source) {
-  if ('links' in source) {
-    target.links = source.links;
-  }
-  if ('meta' in source) {
-    target.meta = source.meta;
+
+  /**
+    Saves all of the records in the `ManyArray`.
+     Note: this API can only be used in legacy mode with a configured Adapter.
+     Example
+     ```javascript
+    const { content: { data: inbox } } = await store.request(findRecord({ type: 'inbox', id: '1' }));
+     let messages = await inbox.messages;
+    messages.forEach((message) => {
+      message.isRead = true;
+    });
+    messages.save();
+    ```
+     @method save
+    @public
+    @return {PromiseArray} promise
+  */
+
+  /**
+    Create a child record within the owner
+     @method createRecord
+    @public
+    @param {Object} hash
+    @return {Model} record
+  */
+  createRecord(hash) {
+    const {
+      store
+    } = this;
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected modelName to be set`);
+      }
+    })(this.modelName) : {};
+    const record = store.createRecord(this.modelName, hash);
+    this.push(record);
+    return record;
   }
-  if ('errors' in source) {
-    target.errors = source.errors;
+  destroy() {
+    super.destroy(false);
   }
 }
-function isCacheAffecting(document) {
-  if (!isMutation(document.request)) {
-    return true;
-  }
-  // a mutation combined with a 204 has no cache impact when no known records were involved
-  // a createRecord with a 201 with an empty response and no known records should similarly
-  // have no cache impact
-
-  if (document.request.op === 'createRecord' && document.response?.status === 201) {
-    return document.content ? Object.keys(document.content).length > 0 : false;
+RelatedCollection.prototype.isAsync = false;
+RelatedCollection.prototype.isPolymorphic = false;
+RelatedCollection.prototype.identifier = null;
+RelatedCollection.prototype.cache = null;
+RelatedCollection.prototype._inverseIsAsync = false;
+RelatedCollection.prototype.key = '';
+RelatedCollection.prototype.DEPRECATED_CLASS_NAME = 'ManyArray';
+function assertRecordPassedToHasMany(record) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`All elements of a hasMany relationship must be instances of Model, you passed ${typeof record}`);
+    }
+  })(function () {
+    try {
+      recordIdentifierFor(record);
+      return true;
+    } catch {
+      return false;
+    }
+  }()) : {};
+}
+function extractIdentifiersFromRecords(records) {
+  return records.map(extractIdentifierFromRecord);
+}
+function extractIdentifierFromRecord(recordOrPromiseRecord) {
+  assertRecordPassedToHasMany(recordOrPromiseRecord);
+  return recordIdentifierFor(recordOrPromiseRecord);
+}
+function assertNoDuplicates(collection, target, callback, reason) {
+  const state = target.slice();
+  callback(state);
+  if (state.length !== new Set(state).size) {
+    const duplicates = state.filter((currentValue, currentIndex) => state.indexOf(currentValue) !== currentIndex);
+    if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
+      deprecate(`${reason} This behavior is deprecated. Found duplicates for the following records within the new state provided to \`<${collection.identifier.type}:${collection.identifier.id || collection.identifier.lid}>.${collection.key}\`\n\t- ${Array.from(new Set(duplicates)).map(r => isStableIdentifier(r) ? r.lid : recordIdentifierFor(r).lid).sort((a, b) => a.localeCompare(b)).join('\n\t- ')}`, false, {
+        id: 'ember-data:deprecate-many-array-duplicates',
+        for: 'ember-data',
+        until: '6.0',
+        since: {
+          enabled: '5.3',
+          available: '4.13'
+        }
+      });
+    } else {
+      throw new Error(`${reason} Found duplicates for the following records within the new state provided to \`<${collection.identifier.type}:${collection.identifier.id || collection.identifier.lid}>.${collection.key}\`\n\t- ${Array.from(new Set(duplicates)).map(r => isStableIdentifier(r) ? r.lid : recordIdentifierFor(r).lid).sort((a, b) => a.localeCompare(b)).join('\n\t- ')}`);
+    }
   }
-  return document.response?.status !== 204;
 }
-export { ARRAY_SIGNAL as A, CacheHandler as C, IdentifierArray as I, MUTATE as M, RecordArrayManager as R, Store as S, _clearCaches as _, setIdentifierGenerationMethod as a, setIdentifierUpdateMethod as b, setIdentifierForgetMethod as c, setIdentifierResetMethod as d, setKeyInfoForResource as e, constructResource as f, coerceId as g, ensureStringId as h, isStableIdentifier as i, Collection as j, SOURCE as k, fastPush as l, removeRecordDataFor as m, notifyArray as n, setRecordIdentifier as o, peekCache as p, StoreMap as q, recordIdentifierFor as r, storeFor as s, setCacheFor as t, normalizeModelName as u };
+function mutateAddToRelatedRecords(collection, operationInfo, _SIGNAL) {
+  mutate(collection, {
+    op: 'add',
+    record: collection.identifier,
+    field: collection.key,
+    ...operationInfo
+  }, _SIGNAL);
+}
+function mutateRemoveFromRelatedRecords(collection, operationInfo, _SIGNAL) {
+  mutate(collection, {
+    op: 'remove',
+    record: collection.identifier,
+    field: collection.key,
+    ...operationInfo
+  }, _SIGNAL);
+}
+function mutateReplaceRelatedRecord(collection, operationInfo, _SIGNAL) {
+  mutate(collection, {
+    op: 'replaceRelatedRecord',
+    record: collection.identifier,
+    field: collection.key,
+    ...operationInfo
+  }, _SIGNAL);
+}
+function mutateReplaceRelatedRecords(collection, value, _SIGNAL) {
+  mutate(collection, {
+    op: 'replaceRelatedRecords',
+    record: collection.identifier,
+    field: collection.key,
+    value
+  }, _SIGNAL);
+}
+function mutateSortRelatedRecords(collection, value, _SIGNAL) {
+  mutate(collection, {
+    op: 'sortRelatedRecords',
+    record: collection.identifier,
+    field: collection.key,
+    value
+  }, _SIGNAL);
+}
+function mutate(collection, mutation, _SIGNAL) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected the manager for ManyArray to implement mutate`);
+    }
+  })(typeof collection._manager.mutate === 'function') : {};
+  collection._manager.mutate(mutation);
+  addToTransaction(_SIGNAL);
+}
+export { ARRAY_SIGNAL as A, CacheHandler as C, IdentifierArray as I, MUTATE as M, RecordArrayManager as R, Store as S, _clearCaches as _, setIdentifierGenerationMethod as a, setIdentifierUpdateMethod as b, setIdentifierForgetMethod as c, setIdentifierResetMethod as d, setKeyInfoForResource as e, isDocumentIdentifier as f, constructResource as g, coerceId as h, isStableIdentifier as i, ensureStringId as j, Collection as k, SOURCE as l, fastPush as m, notifyArray as n, removeRecordDataFor as o, peekCache as p, setRecordIdentifier as q, recordIdentifierFor as r, storeFor as s, StoreMap as t, setCacheFor as u, normalizeModelName as v, RelatedCollection as w, log as x, logGroup as y };