@ember-data/store 5.3.10 → 5.3.12

package/dist/{handler-CW2kp6Ua.js → many-array-uP6jS6_J.js}

@@ -1,11 +1,12 @@
 import { deprecate, warn } from '@ember/debug';
 import { macroCondition, getGlobalConfig, dependencySatisfies, importSync } from '@embroider/macros';
-import { SkipCache, EnableHydration } from '@warp-drive/core-types/request';
-import { getOrSetGlobal, setTransient, peekTransient } from '@warp-drive/core-types/-private';
-import { CACHE_OWNER, DEBUG_STALE_CACHE_OWNER, DEBUG_CLIENT_ORIGINATED, DEBUG_IDENTIFIER_BUCKET } from '@warp-drive/core-types/identifier';
-import { dasherize } from '@ember-data/request-utils/string';
-import { defineSignal, createSignal, subscribe, createArrayTags, addToTransaction, addTransactionCB } from '@ember-data/tracking/-private';
+import { EnableHydration, SkipCache } from '@warp-drive/core-types/request';
+import { setLogging, getRuntimeConfig } from '@warp-drive/core-types/runtime';
+import { getOrSetGlobal, peekTransient, setTransient } from '@warp-drive/core-types/-private';
 import { _backburner } from '@ember/runloop';
+import { 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,6 +820,87 @@ 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
@@ -1252,9 +1357,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 +1412,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 +1431,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 +1448,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 +1529,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 +1850,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 +2075,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 +2212,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 +2309,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 +2374,6 @@ class NotificationManager {
     this._buffered = new Map();
     this._hasFlush = false;
     this._cache = new Map();
-    this._tokens = new Map();
   }
 
   /**
@@ -2236,17 +2410,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 +2441,7 @@ class NotificationManager {
    */
   unsubscribe(token) {
     if (!this.isDestroyed) {
-      _unsubscribe(this._tokens, token, this._cache);
+      _unsubscribe(token, this._cache);
     }
   }
 
@@ -2280,17 +2463,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 +2479,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 +2512,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 +2538,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 +2553,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 +2565,6 @@ class NotificationManager {
   }
   destroy() {
     this.isDestroyed = true;
-    this._tokens.clear();
     this._cache.clear();
   }
 }
@@ -2682,7 +2886,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 +2927,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 +3079,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 +3093,11 @@ function assertRecordPassedToHasMany(record) {
     }
   }()) : {};
 }
-function extractIdentifierFromRecord$1(record) {
+function extractIdentifierFromRecord$2(record) {
   if (!record) {
     return null;
   }
-  assertRecordPassedToHasMany(record);
+  assertRecordPassedToHasMany$1(record);
   return recordIdentifierFor(record);
 }
 
@@ -2979,6 +3192,9 @@ class RecordArrayManager {
     sync(array, pending, this._set.get(array));
     this._pending.delete(array);
   }
+  mutate(mutation) {
+    this.store.cache.mutate(mutation);
+  }
 
   /**
     Get the `RecordArray` for a modelName, which contains all loaded records of
@@ -3495,6 +3711,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`.
 
 /**
@@ -3622,12 +3950,9 @@ class Store extends BaseClass {
    * import Fetch from '@ember-data/request/fetch';
    *
    * class extends Store {
-   *   constructor() {
-   *     super(...arguments);
-   *     this.requestManager = new RequestManager();
-   *     this.requestManager.use([Fetch]);
-   *     this.requestManager.useCache(CacheHandler);
-   *   }
+   *   requestManager = new RequestManager()
+   *    .use([Fetch])
+   *    .useCache(CacheHandler);
    * }
    * ```
    *
@@ -3869,7 +4194,7 @@ class Store extends BaseClass {
     // the user has had the chance to set the prop.
     const opts = {
       store: this,
-      [EnableHydration]: true
+      [EnableHydration]: requestConfig[EnableHydration] ?? true
     };
     if (requestConfig.records) {
       const identifierCache = this.identifierCache;
@@ -3880,22 +4205,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) {
@@ -4101,9 +4430,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
@@ -5155,14 +5483,16 @@ 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 (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_PAYLOADS)) {
+      if (getGlobalConfig().WarpDrive.debug.LOG_PAYLOADS || globalThis.getWarpDriveRuntimeConfig().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) {
@@ -5385,9 +5715,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]);
         }
       }
     }
@@ -5415,10 +5745,10 @@ 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;
   }
@@ -6066,4 +6396,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: 'addToRelatedRecords',
+    record: collection.identifier,
+    field: collection.key,
+    ...operationInfo
+  }, _SIGNAL);
+}
+function mutateRemoveFromRelatedRecords(collection, operationInfo, _SIGNAL) {
+  mutate(collection, {
+    op: 'removeFromRelatedRecords',
+    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, 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, RelatedCollection as v, log as w, logGroup as x };