@ember-data/store 5.3.11 → 5.3.13

package/dist/{handler-DX830Swd.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 { EnableHydration, SkipCache } 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 { 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';
 
 /**
@@ -129,10 +130,9 @@ 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);
@@ -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,77 +820,461 @@ 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++;
-      }
-    });
+  /**
+   * The primary data for this document, if any.
+   *
+   * If this document has no primary data (e.g. because it is an error document)
+   * this property will be `undefined`.
+   *
+   * For collections this will be an array of record instances,
+   * for single resource requests it will be a single record instance or null.
+   *
+   * @property data
+   * @public
+   * @type {object|Array<object>|null|undefined} - a data object
+   */
+
+  /**
+   * The errors returned by the API for this request, if any
+   *
+   * @property errors
+   * @public
+   * @type {object|undefined} - an errors object
+   */
+
+  /**
+   * The meta object for this document, if any
+   *
+   * @property meta
+   * @public
+   * @type {object|undefined} - a meta object
+   */
+
+  /**
+   * The identifier associated with this document, if any
+   *
+   * @property identifier
+   * @public
+   * @type {StableDocumentIdentifier|null}
+   */
+
+  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;
+        }
+      });
+    }
   }
-  destroy() {
-    this.store.notifications.unsubscribe(this.___token);
+  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;
   }
-  get type() {
-    return this.identifier().type;
+
+  /**
+   * 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);
   }
 
   /**
-     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;
+   * 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);
   }
 
   /**
-     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 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);
   }
 
   /**
-     How the reference will be looked up when it is loaded. Currently
-     this always returns `identity` to signify that a record will be
+   * 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
@@ -1177,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;
@@ -1237,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) {
@@ -1252,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;
@@ -1300,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) {
@@ -1318,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?
@@ -1333,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();
+        }
       }
     });
   }
@@ -1408,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,
@@ -1727,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
@@ -1950,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
    *
@@ -2074,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
   // ===============
 
@@ -2158,27 +2621,51 @@ class CacheManager {
  * @module @ember-data/store
  */
 
-let tokenId = 0;
-const CacheOperations = new Set(['added', 'removed', 'state', 'updated', 'invalidated']);
 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);
   }
 }
 
@@ -2199,7 +2686,6 @@ class NotificationManager {
     this._buffered = new Map();
     this._hasFlush = false;
     this._cache = new Map();
-    this._tokens = new Map();
   }
 
   /**
@@ -2236,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;
   }
 
   /**
@@ -2258,7 +2753,7 @@ class NotificationManager {
    */
   unsubscribe(token) {
     if (!this.isDestroyed) {
-      _unsubscribe(this._tokens, token, this._cache);
+      _unsubscribe(token, this._cache);
     }
   }
 
@@ -2280,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) {
@@ -2298,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;
   }
@@ -2309,14 +2824,15 @@ 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() {
     const buffered = this._buffered;
@@ -2334,9 +2850,10 @@ class NotificationManager {
     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
@@ -2348,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);
     });
@@ -2360,7 +2877,6 @@ class NotificationManager {
   }
   destroy() {
     this.isDestroyed = true;
-    this._tokens.clear();
     this._cache.clear();
   }
 }
@@ -2474,6 +2990,7 @@ class IdentifierArray {
   isDestroying = false;
   isDestroyed = false;
   _updatingPromise = null;
+  identifier;
   [IS_COLLECTION] = true;
   [SOURCE];
   [NOTIFY]() {
@@ -2512,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;
@@ -2682,7 +3200,7 @@ class IdentifierArray {
           return false;
         }
         const original = target[index];
-        const newIdentifier = extractIdentifierFromRecord$1(value);
+        const newIdentifier = extractIdentifierFromRecord$2(value);
         macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
           if (!test) {
             throw new Error(`Expected a record`);
@@ -2723,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;
@@ -2866,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}`);
@@ -2880,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);
 }
 
@@ -2959,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);
@@ -2973,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);
   }
 
   /**
@@ -3013,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,
@@ -3028,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]);
@@ -3096,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);
@@ -3116,7 +3691,7 @@ class RecordArrayManager {
           changes.delete(identifier);
         } else {
           changes.set(identifier, 'add');
-          this.dirtyArray(array, changes.size);
+          this.dirtyArray(array, changes.size, false);
         }
       });
     }
@@ -3130,7 +3705,7 @@ class RecordArrayManager {
           changes.delete(identifier);
         } else {
           changes.set(identifier, 'del');
-          this.dirtyArray(array, changes.size);
+          this.dirtyArray(array, changes.size, false);
         }
       });
     }
@@ -3235,6 +3810,9 @@ function sync(array, changes, arraySet) {
     */
   }
 }
+function isCollection(array) {
+  return array.identifier !== null;
+}
 
 /**
  * @module @ember-data/store
@@ -3495,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`.
 
 /**
@@ -3561,6 +4251,7 @@ 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: '4.13',
       enabled: '5.4'
@@ -3708,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;
   }
@@ -3877,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) {
@@ -4098,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
@@ -5152,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 {
-        // eslint-disable-next-line no-console
-        console.log('EmberData | Payload - push', jsonApiDoc);
-      }
-    }
     if (asyncFlush) {
       this._enableAsyncFlush = true;
     }
@@ -5382,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]);
         }
       }
     }
@@ -5412,222 +6095,16 @@ 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);
 }
-
-/**
- * @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.
- *
- * It is not directly instantiated by the user, and its properties should not
- * be directly modified. Whether individual properties are mutable or not is
- * determined by the record instance itself.
- *
- * @public
- * @class Document
- */
-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
-   */
-
-  /**
-   * The identifier associated with this document, if any
-   *
-   * @property identifier
-   * @public
-   * @type {StableDocumentIdentifier|null}
-   */
-
-  #store;
-  constructor(store, identifier) {
-    this.#store = store;
-    this.identifier = identifier;
-  }
-  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;
-  }
-
-  /**
-   * 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);
-  }
-
-  /**
-   * 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;
-  }
-}
-defineSignal(Document.prototype, 'data');
-defineSignal(Document.prototype, 'links');
-defineSignal(Document.prototype, 'errors');
-defineSignal(Document.prototype, 'meta');
 const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);
 function calcShouldFetch(store, request, hasCachedValue, identifier) {
   const {
@@ -5644,17 +6121,6 @@ function calcShouldBackgroundFetch(store, request, willFetch, identifier) {
 function isMutation(request) {
   return Boolean(request.op && MUTATION_OPS.has(request.op));
 }
-function copyDocumentProperties(target, source) {
-  if ('links' in source) {
-    target.links = source.links;
-  }
-  if ('meta' in source) {
-    target.meta = source.meta;
-  }
-  if ('errors' in source) {
-    target.errors = source.errors;
-  }
-}
 function isCacheAffecting(document) {
   if (!isMutation(document.request)) {
     return true;
@@ -5682,9 +6148,6 @@ function cloneError(error) {
   Object.assign(cloned, error);
   return cloned;
 }
-function isErrorDocument(document) {
-  return 'errors' in document;
-}
 function getPriority(identifier, deduped, priority) {
   if (identifier) {
     const existing = deduped.get(identifier);
@@ -5814,10 +6277,10 @@ const CacheHandler = {
     const shouldHydrate = context.request[EnableHydration] || false;
     context.setResponse(peeked.response);
     if ('error' in peeked) {
-      const content = shouldHydrate ? maybeUpdateErrorUiObjects(store, {
+      const content = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
         shouldHydrate,
         identifier
-      }, peeked.content, true) : peeked.content;
+      }, peeked.content) : peeked.content;
       const newError = cloneError(peeked);
       newError.content = content;
       throw newError;
@@ -5825,15 +6288,15 @@ const CacheHandler = {
     const result = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
       shouldHydrate,
       identifier
-    }, peeked.content, true) : peeked.content;
+    }, peeked.content) : peeked.content;
     return result;
   }
 };
-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`);
@@ -5841,97 +6304,16 @@ function maybeUpdateUiObjects(store, request, options, document, isFromCache) {
     })(!options.shouldHydrate) : {};
     return document;
   }
-  if (Array.isArray(document.data)) {
-    const {
-      recordArrayManager
-    } = store;
-    if (!identifier) {
-      if (!options.shouldHydrate) {
-        return document;
-      }
-      const data = recordArrayManager.createArray({
-        type: request.url,
-        identifiers: document.data,
-        doc: document,
-        query: request
-      });
-      const doc = new Document(store, null);
-      doc.data = data;
-      doc.meta = document.meta;
-      doc.links = document.links;
-      return doc;
-    }
-    let managed = recordArrayManager._keyedArrays.get(identifier.lid);
-    if (!managed) {
-      managed = recordArrayManager.createArray({
-        type: identifier.lid,
-        identifiers: document.data,
-        doc: document
-      });
-      recordArrayManager._keyedArrays.set(identifier.lid, managed);
-      const doc = new Document(store, identifier);
-      doc.data = managed;
-      doc.meta = document.meta;
-      doc.links = document.links;
-      store._documentCache.set(identifier, doc);
-      return options.shouldHydrate ? doc : document;
-    } else {
-      const doc = store._documentCache.get(identifier);
-      if (!isFromCache) {
-        recordArrayManager.populateManagedArray(managed, document.data, document);
-        doc.data = managed;
-        doc.meta = document.meta;
-        doc.links = document.links;
-      }
-      return options.shouldHydrate ? doc : document;
-    }
-  } else {
-    if (!identifier && !options.shouldHydrate) {
-      return document;
-    }
-    const data = document.data ? store.peekRecord(document.data) : null;
-    let doc;
-    if (identifier) {
-      doc = store._documentCache.get(identifier);
-    }
-    if (!doc) {
-      doc = new Document(store, identifier);
-      doc.data = data;
-      copyDocumentProperties(doc, document);
-      if (identifier) {
-        store._documentCache.set(identifier, doc);
-      }
-    } else if (!isFromCache) {
-      doc.data = data;
-      copyDocumentProperties(doc, document);
-    }
-    return options.shouldHydrate ? doc : document;
-  }
-}
-function maybeUpdateErrorUiObjects(store, options, document, isFromCache) {
-  const {
-    identifier
-  } = options;
-
-  // TODO investigate why ResourceErrorDocument is insufficient for expressing all error types
-  if (!isErrorDocument(document) || !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 store._instanceCache.getDocument(identifier);
   }
-  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;
@@ -5949,7 +6331,7 @@ function updateCacheForSuccess(store, request, options, document) {
   } else {
     response = store.cache.put(document);
   }
-  return maybeUpdateUiObjects(store, request, options, response, false);
+  return maybeUpdateUiObjects(store, request, options, response);
 }
 function handleFetchSuccess(store, context, options, document) {
   const {
@@ -5982,7 +6364,7 @@ function updateCacheForError(store, context, options, error) {
     store.cache.commitWasRejected(record, errors);
   } else {
     response = store.cache.put(error);
-    return maybeUpdateErrorUiObjects(store, options, response, false);
+    return maybeUpdateUiObjects(store, context.request, options, response);
   }
 }
 function handleFetchError(store, context, options, error) {
@@ -6063,4 +6445,475 @@ function fetchContentAndHydrate(next, context, identifier, priority) {
     }]
   });
 }
-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 };
+
+/**
+  @module @ember-data/store
+*/
+/**
+  A `ManyArray` is a `MutableArray` that represents the contents of a has-many
+  relationship.
+
+  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
+    */
+
+  /**
+     * 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 the manager for ManyArray to implement reloadHasMany`);
+      }
+    })(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);
+  }
+
+  /**
+    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;
+  }
+  destroy() {
+    super.destroy(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- ')}`);
+    }
+  }
+}
+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 };