@ember-data/store 5.4.0-beta.4 → 5.4.0-beta.6

package/{addon/cache-handler-XLbbNJdo.js → dist/cache-handler-C5ilAUZ5.js}

@@ -1,10 +1,10 @@
-import { deprecate, assert, warn } from '@ember/debug';
-import EmberObject from '@ember/object';
+import { deprecate, warn } from '@ember/debug';
+import { macroCondition, getGlobalConfig, dependencySatisfies, importSync } from '@embroider/macros';
 import { SkipCache, EnableHydration } from '@warp-drive/core-types/request';
-import { macroCondition, getOwnConfig } from '@embroider/macros';
+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/string';
-import { defineSignal, addToTransaction, createSignal, subscribe, createArrayTags, addTransactionCB } from '@ember-data/tracking/-private';
+import { dasherize } from '@ember-data/request-utils/string';
+import { defineSignal, createSignal, subscribe, createArrayTags, addToTransaction, addTransactionCB } from '@ember-data/tracking/-private';
 import { _backburner } from '@ember/runloop';
 import { compat } from '@ember-data/tracking';
 
@@ -13,7 +13,7 @@ import { compat } from '@ember-data/tracking';
 */
 
 function coerceId(id) {
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_NON_STRICT_ID)) {
+  if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_NON_STRICT_ID)) {
     let normalized;
     if (id === null || id === undefined || id === '') {
       normalized = null;
@@ -31,7 +31,11 @@ function coerceId(id) {
     });
     return normalized;
   }
-  assert(`Resource IDs must be a non-empty string or null. Received '${String(id)}'.`, id === null || typeof id === 'string' && id.length > 0);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Resource IDs must be a non-empty string or null. Received '${String(id)}'.`);
+    }
+  })(id === null || typeof id === 'string' && id.length > 0) : {};
   return id;
 }
 function ensureStringId(id) {
@@ -41,11 +45,15 @@ function ensureStringId(id) {
   } else if (typeof id === 'number' && !isNaN(id)) {
     normalized = String(id);
   }
-  assert(`Expected id to be a string or number, received ${String(id)}`, normalized !== null);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected id to be a string or number, received ${String(id)}`);
+    }
+  })(normalized !== null) : {};
   return normalized;
 }
 function normalizeModelName(type) {
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_NON_STRICT_TYPES)) {
+  if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_NON_STRICT_TYPES)) {
     const result = dasherize(type);
     deprecate(`The resource type '${type}' is not normalized. Update your application code to use '${result}' instead of '${type}'.`, result === type, {
       id: 'ember-data:deprecate-non-strict-types',
@@ -121,8 +129,8 @@ function hasType(resource) {
 /**
   @module @ember-data/store
 */
-const IDENTIFIERS = new Set();
-const DOCUMENTS = new Set();
+const IDENTIFIERS = getOrSetGlobal('IDENTIFIERS', new Set());
+const DOCUMENTS = getOrSetGlobal('DOCUMENTS', new Set());
 function isStableIdentifier(identifier) {
   return identifier[CACHE_OWNER] !== undefined || IDENTIFIERS.has(identifier);
 }
@@ -131,11 +139,15 @@ function isDocumentIdentifier(identifier) {
 }
 const isFastBoot = typeof FastBoot !== 'undefined';
 const _crypto = isFastBoot ? FastBoot.require('crypto') : window.crypto;
-if (macroCondition(getOwnConfig().polyfillUUID)) {
+if (macroCondition(getGlobalConfig().WarpDrive.polyfillUUID)) {
   installPolyfill();
 }
 function uuidv4() {
-  assert('crypto.randomUUID needs to be avaliable. Some browsers incorrectly disallow it in insecure contexts. You maybe want to enable the polyfill: https://github.com/emberjs/data#randomuuid-polyfill', typeof _crypto.randomUUID === 'function');
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error('crypto.randomUUID needs to be avaliable. Some browsers incorrectly disallow it in insecure contexts. You maybe want to enable the polyfill: https://github.com/emberjs/data#randomuuid-polyfill');
+    }
+  })(typeof _crypto.randomUUID === 'function') : {};
   return _crypto.randomUUID();
 }
 function freeze(obj) {
@@ -148,26 +160,27 @@ function freeze(obj) {
 // type IdentifierTypeLookup = { all: Set<StableRecordIdentifier>; id: Map<string, StableRecordIdentifier> };
 // type IdentifiersByType = Map<string, IdentifierTypeLookup>;
 
-let configuredForgetMethod;
-let configuredGenerationMethod;
-let configuredResetMethod;
-let configuredUpdateMethod;
 function setIdentifierGenerationMethod(method) {
-  configuredGenerationMethod = method;
+  setTransient('configuredGenerationMethod', method);
 }
 function setIdentifierUpdateMethod(method) {
-  configuredUpdateMethod = method;
+  setTransient('configuredUpdateMethod', method);
 }
 function setIdentifierForgetMethod(method) {
-  configuredForgetMethod = method;
+  setTransient('configuredForgetMethod', method);
 }
 function setIdentifierResetMethod(method) {
-  configuredResetMethod = method;
+  setTransient('configuredResetMethod', method);
+}
+function setKeyInfoForResource(method) {
+  setTransient('configuredKeyInfoMethod', method);
 }
 
 // Map<type, Map<id, lid>>
 
+// TODO can we just delete this?
 const NEW_IDENTIFIERS = new Map();
+// TODO @runspired maybe needs peekTransient ?
 let IDENTIFIER_CACHE_ID = 0;
 function updateTypeIdMapping(typeMap, identifier, id) {
   let idMap = typeMap.get(identifier.type);
@@ -179,7 +192,11 @@ function updateTypeIdMapping(typeMap, identifier, id) {
 }
 function defaultUpdateMethod(identifier, data, bucket) {
   if (bucket === 'record') {
-    assert(`Expected identifier to be a StableRecordIdentifier`, isStableIdentifier(identifier));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected identifier to be a StableRecordIdentifier`);
+      }
+    })(isStableIdentifier(identifier)) : {};
     if (!identifier.id && hasId(data)) {
       updateTypeIdMapping(NEW_IDENTIFIERS, identifier, data.id);
     }
@@ -189,7 +206,11 @@ function defaultKeyInfoMethod(resource, known) {
   // TODO RFC something to make this configurable
   const id = hasId(resource) ? coerceId(resource.id) : null;
   const type = hasType(resource) ? normalizeModelName(resource.type) : known ? known.type : null;
-  assert(`Expected keyInfoForResource to provide a type for the resource`, type);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected keyInfoForResource to provide a type for the resource`);
+    }
+  })(type) : {};
   return {
     type,
     id
@@ -200,7 +221,11 @@ function defaultGenerationMethod(data, bucket) {
     if (hasLid(data)) {
       return data.lid;
     }
-    assert(`Cannot generate an identifier for a resource without a type`, hasType(data));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Cannot generate an identifier for a resource without a type`);
+      }
+    })(hasType(data)) : {};
     if (hasId(data)) {
       const type = normalizeModelName(data.type);
       const lid = NEW_IDENTIFIERS.get(type)?.get(data.id);
@@ -216,15 +241,19 @@ function defaultGenerationMethod(data, bucket) {
     }
     return null;
   }
-  assert(`Unknown bucket ${bucket}`, false);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    {
+      throw new Error(`Unknown bucket ${bucket}`);
+    }
+  })() : {};
 }
 function defaultEmptyCallback(...args) {}
 function defaultMergeMethod(a, _b, _c) {
   return a;
 }
 let DEBUG_MAP;
-if (macroCondition(getOwnConfig().env.DEBUG)) {
-  DEBUG_MAP = new WeakMap();
+if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+  DEBUG_MAP = getOrSetGlobal('DEBUG_MAP', new WeakMap());
 }
 
 /**
@@ -244,13 +273,12 @@ class IdentifierCache {
   constructor() {
     // we cache the user configuredGenerationMethod at init because it must
     // be configured prior and is not allowed to be changed
-    this._generate = configuredGenerationMethod || defaultGenerationMethod;
-    this._update = configuredUpdateMethod || defaultUpdateMethod;
-    this._forget = configuredForgetMethod || defaultEmptyCallback;
-    this._reset = configuredResetMethod || defaultEmptyCallback;
+    this._generate = peekTransient('configuredGenerationMethod') || defaultGenerationMethod;
+    this._update = peekTransient('configuredUpdateMethod') || defaultUpdateMethod;
+    this._forget = peekTransient('configuredForgetMethod') || defaultEmptyCallback;
+    this._reset = peekTransient('configuredResetMethod') || defaultEmptyCallback;
     this._merge = defaultMergeMethod;
-    this._keyInfoForResource = defaultKeyInfoMethod;
-    this._isDefaultConfig = !configuredGenerationMethod;
+    this._keyInfoForResource = peekTransient('configuredKeyInfoMethod') || defaultKeyInfoMethod;
     this._id = IDENTIFIER_CACHE_ID++;
     this._cache = {
       resources: new Map(),
@@ -282,19 +310,19 @@ class IdentifierCache {
    */
 
   _getRecordIdentifier(resource, shouldGenerate) {
-    if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.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)) {
-      if (macroCondition(getOwnConfig().env.DEBUG)) {
+      if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
         // TODO should we instead just treat this case as a new generation skipping the short circuit?
         if (!this._cache.resources.has(resource.lid) || this._cache.resources.get(resource.lid) !== resource) {
           throw new Error(`The supplied identifier ${JSON.stringify(resource)} does not belong to this store instance`);
         }
       }
-      if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
+      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
@@ -305,20 +333,20 @@ class IdentifierCache {
 
     // the resource is unknown, ask the application to identify this data for us
     const lid = this._generate(resource, 'record');
-    if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
+    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);
     }
     let identifier = /*#__NOINLINE__*/getIdentifierFromLid(this._cache, lid, resource);
     if (identifier !== null) {
-      if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
+      if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
         // eslint-disable-next-line no-console
         console.groupEnd();
       }
       return identifier;
     }
     if (shouldGenerate === 0) {
-      if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
+      if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
         // eslint-disable-next-line no-console
         console.groupEnd();
       }
@@ -338,7 +366,7 @@ class IdentifierCache {
       identifier = /*#__NOINLINE__*/makeStableRecordIdentifier(keyInfo, 'record', false);
     }
     addResourceToCache(this._cache, identifier);
-    if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
       // eslint-disable-next-line no-console
       console.groupEnd();
     }
@@ -380,7 +408,7 @@ class IdentifierCache {
       identifier = {
         lid: cacheKey
       };
-      if (macroCondition(getOwnConfig().env.DEBUG)) {
+      if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
         Object.freeze(identifier);
       }
       DOCUMENTS.add(identifier);
@@ -426,7 +454,7 @@ class IdentifierCache {
     }, 'record', true);
 
     // populate our unique table
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       if (this._cache.resources.has(identifier.lid)) {
         throw new Error(`The lid generated for the new record is not unique as it matches an existing identifier`);
       }
@@ -434,7 +462,7 @@ class IdentifierCache {
 
     /*#__NOINLINE__*/
     addResourceToCache(this._cache, identifier);
-    if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
+    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);
     }
@@ -483,7 +511,7 @@ class IdentifierCache {
       if (hadLid) {
         data.lid = identifier.lid;
       }
-      if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
+      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);
       }
@@ -495,17 +523,21 @@ class IdentifierCache {
 
     // add to our own secondary lookup table
     if (id !== newId && newId !== null) {
-      if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
+      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);
       }
       const typeSet = this._cache.resourcesByType[identifier.type];
-      assert(`Expected to find a typeSet for ${identifier.type}`, typeSet);
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Expected to find a typeSet for ${identifier.type}`);
+        }
+      })(typeSet) : {};
       typeSet.id.set(newId, identifier);
       if (id !== null) {
         typeSet.id.delete(id);
       }
-    } else if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
+    } else if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
       // eslint-disable-next-line no-console
       console.log(`Identifiers: updated identifier ${identifier.lid} resource`, data);
     }
@@ -517,7 +549,11 @@ class IdentifierCache {
    * @private
    */
   _mergeRecordIdentifiers(keyInfo, identifier, existingIdentifier, data) {
-    assert(`Expected keyInfo to contain an id`, hasId(keyInfo));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected keyInfo to contain an id`);
+      }
+    })(hasId(keyInfo)) : {};
     // delegate determining which identifier to keep to the configured MergeMethod
     const kept = this._merge(identifier, existingIdentifier, data);
     const abandoned = kept === identifier ? existingIdentifier : identifier;
@@ -564,7 +600,11 @@ class IdentifierCache {
   forgetRecordIdentifier(identifierObject) {
     const identifier = this.getOrCreateRecordIdentifier(identifierObject);
     const typeSet = this._cache.resourcesByType[identifier.type];
-    assert(`Expected to find a typeSet for ${identifier.type}`, typeSet);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected to find a typeSet for ${identifier.type}`);
+      }
+    })(typeSet) : {};
     if (identifier.id !== null) {
       typeSet.id.delete(identifier.id);
     }
@@ -577,13 +617,13 @@ class IdentifierCache {
       });
       this._cache.polymorphicLidBackMap.delete(identifier.lid);
     }
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       identifier[DEBUG_STALE_CACHE_OWNER] = identifier[CACHE_OWNER];
     }
     identifier[CACHE_OWNER] = undefined;
     IDENTIFIERS.delete(identifier);
     this._forget(identifier, 'record');
-    if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
       // eslint-disable-next-line no-console
       console.log(`Identifiers: released identifier ${identifierObject.lid}`);
     }
@@ -598,7 +638,7 @@ class IdentifierCache {
 }
 function makeStableRecordIdentifier(recordIdentifier, bucket, clientOriginated) {
   IDENTIFIERS.add(recordIdentifier);
-  if (macroCondition(getOwnConfig().env.DEBUG)) {
+  if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
     // we enforce immutability in dev
     //  but preserve our ability to do controlled updates to the reference
     let wrapper = {
@@ -660,7 +700,7 @@ function makeStableRecordIdentifier(recordIdentifier, bucket, clientOriginated)
   return recordIdentifier;
 }
 function performRecordIdentifierUpdate(identifier, keyInfo, data, updateFn) {
-  if (macroCondition(getOwnConfig().env.DEBUG)) {
+  if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
     const {
       id,
       type
@@ -735,7 +775,7 @@ function detectMerge(cache, keyInfo, identifier, data) {
 }
 function getIdentifierFromLid(cache, lid, resource) {
   const identifier = cache.resources.get(lid);
-  if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
+  if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS)) {
     // eslint-disable-next-line no-console
     console.log(`Identifiers: cache ${identifier ? 'HIT' : 'MISS'} - Non-Stable ${lid}`, resource);
   }
@@ -761,10 +801,6 @@ function addResourceToCache(cache, identifier) {
   @module @ember-data/store
 */
 
-/**
-  @module @ember-data/store
-*/
-
 /**
    A `RecordReference` is a low-level API that allows users and
    addon authors to perform meta-operations on a record.
@@ -773,10 +809,10 @@ function addResourceToCache(cache, identifier) {
    @public
 */
 class RecordReference {
+  // unsubscribe token given to us by the notification manager
+  ___token;
+  ___identifier;
   constructor(store, identifier) {
-    // unsubscribe token given to us by the notification manager
-    this.___token = void 0;
-    this.___identifier = void 0;
     this.store = store;
     this.___identifier = identifier;
     this.___token = store.notifications.subscribe(identifier, (_, bucket, notifiedKey) => {
@@ -919,7 +955,11 @@ class RecordReference {
     if (id !== null) {
       return this.store.findRecord(this.type, id);
     }
-    assert(`Unable to fetch record of type ${this.type} without an id`);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      {
+        throw new Error(`Unable to fetch record of type ${this.type} without an id`);
+      }
+    })() : {};
   }
 
   /**
@@ -942,7 +982,11 @@ class RecordReference {
         reload: true
       });
     }
-    assert(`Unable to fetch record of type ${this.type} without an id`);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      {
+        throw new Error(`Unable to fetch record of type ${this.type} without an id`);
+      }
+    })() : {};
   }
 }
 defineSignal(RecordReference.prototype, '_ref');
@@ -950,7 +994,6 @@ defineSignal(RecordReference.prototype, '_ref');
 /**
   @module @ember-data/store
 */
-
 class CacheCapabilitiesManager {
   constructor(_store) {
     this._store = _store;
@@ -995,7 +1038,11 @@ class CacheCapabilitiesManager {
     });
   }
   notifyChange(identifier, namespace, key) {
-    assert(`Expected a stable identifier`, isStableIdentifier(identifier) || isDocumentIdentifier(identifier));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected a stable identifier`);
+      }
+    })(isStableIdentifier(identifier) || isDocumentIdentifier(identifier)) : {};
 
     // TODO do we still get value from this?
     if (namespace === 'relationships' && key) {
@@ -1006,34 +1053,49 @@ class CacheCapabilitiesManager {
     // @ts-expect-error
     this._store.notifications.notify(identifier, namespace, key);
   }
-  getSchemaDefinitionService() {
-    return this._store.getSchemaDefinitionService();
-  }
   get schema() {
     return this._store.schema;
   }
   setRecordId(identifier, id) {
-    assert(`Expected a stable identifier`, isStableIdentifier(identifier));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected a stable identifier`);
+      }
+    })(isStableIdentifier(identifier)) : {};
     this._store._instanceCache.setRecordId(identifier, id);
   }
   hasRecord(identifier) {
     return Boolean(this._store._instanceCache.peek(identifier));
   }
   disconnectRecord(identifier) {
-    assert(`Expected a stable identifier`, isStableIdentifier(identifier));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected a stable identifier`);
+      }
+    })(isStableIdentifier(identifier)) : {};
     this._store._instanceCache.disconnect(identifier);
     this._pendingNotifies.delete(identifier);
   }
 }
+if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA_SERVICE)) {
+  CacheCapabilitiesManager.prototype.getSchemaDefinitionService = function () {
+    // FIXME add deprecation for this
+    return this._store.schema;
+  };
+}
 
 /*
  * Returns the Cache instance associated with a given
  * Model or Identifier
  */
 
-const CacheForIdentifierCache = new Map();
+const CacheForIdentifierCache = getOrSetGlobal('CacheForIdentifierCache', new Map());
 function setCacheFor(identifier, cache) {
-  assert(`Illegal set of identifier`, !CacheForIdentifierCache.has(identifier) || CacheForIdentifierCache.get(identifier) === cache);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Illegal set of identifier`);
+    }
+  })(!CacheForIdentifierCache.has(identifier) || CacheForIdentifierCache.get(identifier) === cache) : {};
   CacheForIdentifierCache.set(identifier, cache);
 }
 function removeRecordDataFor(identifier) {
@@ -1053,7 +1115,7 @@ function isDestroyable(record) {
   @module @ember-data/store
 */
 
-const RecordCache = new Map();
+const RecordCache = getOrSetGlobal('RecordCache', new Map());
 function peekRecordIdentifier(record) {
   return RecordCache.get(record);
 }
@@ -1077,12 +1139,17 @@ function peekRecordIdentifier(record) {
   @param {Object} record a record instance previously obstained from the store.
   @return {StableRecordIdentifier}
  */
+
 function recordIdentifierFor(record) {
-  assert(`${String(record)} is not a record instantiated by @ember-data/store`, RecordCache.has(record));
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`${String(record)} is not a record instantiated by @ember-data/store`);
+    }
+  })(RecordCache.has(record)) : {};
   return RecordCache.get(record);
 }
 function setRecordIdentifier(record, identifier) {
-  if (macroCondition(getOwnConfig().env.DEBUG)) {
+  if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
     if (RecordCache.has(record) && RecordCache.get(record) !== identifier) {
       throw new Error(`${String(record)} was already assigned an identifier`);
     }
@@ -1098,18 +1165,22 @@ function setRecordIdentifier(record, identifier) {
 
   RecordCache.set(record, identifier);
 }
-const StoreMap = new Map();
+const StoreMap = getOrSetGlobal('StoreMap', new Map());
 function storeFor(record) {
   const store = StoreMap.get(record);
-  assert(`A record in a disconnected state cannot utilize the store. This typically means the record has been destroyed, most commonly by unloading it.`, store);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`A record in a disconnected state cannot utilize the store. This typically means the record has been destroyed, most commonly by unloading it.`);
+    }
+  })(store) : {};
   return store;
 }
 class InstanceCache {
+  __instances = {
+    record: new Map(),
+    reference: new WeakMap()
+  };
   constructor(store) {
-    this.__instances = {
-      record: new Map(),
-      reference: new WeakMap()
-    };
     this.store = store;
     this._storeWrapper = new CacheCapabilitiesManager(this.store);
     store.identifierCache.__configureMerge((identifier, matchedIdentifier, resourceData) => {
@@ -1139,7 +1210,11 @@ class InstanceCache {
         if ('id' in resourceData) {
           throw new Error(`Failed to update the 'id' for the RecordIdentifier '${identifier.type}:${String(identifier.id)} (${identifier.lid})' to '${String(resourceData.id)}', because that id is already in use by '${matchedIdentifier.type}:${String(matchedIdentifier.id)} (${matchedIdentifier.lid})'`);
         }
-        assert(`Failed to update the RecordIdentifier '${identifier.type}:${String(identifier.id)} (${identifier.lid})' to merge with the detected duplicate identifier '${matchedIdentifier.type}:${String(matchedIdentifier.id)} (${String(matchedIdentifier.lid)})'`);
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Failed to update the RecordIdentifier '${identifier.type}:${String(identifier.id)} (${identifier.lid})' to merge with the detected duplicate identifier '${matchedIdentifier.type}:${String(matchedIdentifier.id)} (${String(matchedIdentifier.lid)})'`);
+          }
+        })() : {};
       }
       this.store.cache.patch({
         op: 'mergeIdentifiers',
@@ -1164,7 +1239,11 @@ class InstanceCache {
   getRecord(identifier, properties) {
     let record = this.__instances.record.get(identifier);
     if (!record) {
-      assert(`Cannot create a new record instance while the store is being destroyed`, !this.store.isDestroying && !this.store.isDestroyed);
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Cannot create a new record instance while the store is being destroyed`);
+        }
+      })(!this.store.isDestroying && !this.store.isDestroyed) : {};
       const cache = this.store.cache;
       setCacheFor(identifier, cache);
       record = this.store.instantiateRecord(identifier, properties || {});
@@ -1172,7 +1251,7 @@ class InstanceCache {
       setCacheFor(record, cache);
       StoreMap.set(record, this.store);
       this.__instances.record.set(identifier, record);
-      if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+      if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE)) {
         // eslint-disable-next-line no-console
         console.log(`InstanceCache: created Record for ${String(identifier)}`, properties);
       }
@@ -1211,26 +1290,34 @@ class InstanceCache {
   }
   disconnect(identifier) {
     const record = this.__instances.record.get(identifier);
-    assert('Cannot destroy record while it is still materialized', !isDestroyable(record) || record.isDestroyed || record.isDestroying);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error('Cannot destroy record while it is still materialized');
+      }
+    })(!isDestroyable(record) || record.isDestroyed || record.isDestroying) : {};
     this.store._graph?.remove(identifier);
     this.store.identifierCache.forgetRecordIdentifier(identifier);
     removeRecordDataFor(identifier);
     this.store._requestCache._clearEntries(identifier);
-    if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE)) {
       // eslint-disable-next-line no-console
       console.log(`InstanceCache: disconnected ${String(identifier)}`);
     }
   }
   unloadRecord(identifier) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       const requests = this.store.getRequestStateService().getPendingRequestsForRecord(identifier);
       if (requests.some(req => {
         return req.type === 'mutation';
       })) {
-        assert(`You can only unload a record which is not inFlight. '${String(identifier)}'`);
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`You can only unload a record which is not inFlight. '${String(identifier)}'`);
+          }
+        })() : {};
       }
     }
-    if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE)) {
       // eslint-disable-next-line no-console
       console.groupCollapsed(`InstanceCache: unloading record for ${String(identifier)}`);
     }
@@ -1245,7 +1332,7 @@ class InstanceCache {
         StoreMap.delete(record);
         RecordCache.delete(record);
         removeRecordDataFor(record);
-        if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+        if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE)) {
           // eslint-disable-next-line no-console
           console.log(`InstanceCache: destroyed record for ${String(identifier)}`);
         }
@@ -1253,7 +1340,7 @@ class InstanceCache {
       if (cache) {
         cache.unloadRecord(identifier);
         removeRecordDataFor(identifier);
-        if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+        if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE)) {
           // eslint-disable-next-line no-console
           console.log(`InstanceCache: destroyed cache for ${String(identifier)}`);
         }
@@ -1261,7 +1348,7 @@ class InstanceCache {
         this.disconnect(identifier);
       }
       this.store._requestCache._clearEntries(identifier);
-      if (macroCondition(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+      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
@@ -1300,11 +1387,19 @@ class InstanceCache {
     const oldId = identifier.id;
 
     // ID absolutely can't be missing if the oldID is empty (missing Id in response for a new record)
-    assert(`'${type}' was saved to the server, but the response does not have an id and your record does not either.`, !(id === null && oldId === null));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`'${type}' was saved to the server, but the response does not have an id and your record does not either.`);
+      }
+    })(!(id === null && oldId === null)) : {};
 
     // ID absolutely can't be different than oldID if oldID is not null
     // TODO this assertion and restriction may not strictly be needed in the identifiers world
-    assert(`Cannot update the id for '${type}:${lid}' from '${String(oldId)}' to '${id}'.`, !(oldId !== null && id !== oldId));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Cannot update the id for '${type}:${lid}' from '${String(oldId)}' to '${id}'.`);
+      }
+    })(!(oldId !== null && id !== oldId)) : {};
 
     // ID can be null if oldID is not null (altered ID in response for a record)
     // however, this is more than likely a developer error.
@@ -1312,7 +1407,7 @@ 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(getOwnConfig().debug.LOG_INSTANCE_CACHE)) {
+    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)}`);
     }
@@ -1320,7 +1415,11 @@ class InstanceCache {
       type,
       id
     });
-    assert(`'${type}' was saved to the server, but the response returned the new id '${id}', which has already been used with another record.'`, !existingIdentifier || existingIdentifier === identifier);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`'${type}' was saved to the server, but the response returned the new id '${id}', which has already been used with another record.'`);
+      }
+    })(!existingIdentifier || existingIdentifier === identifier) : {};
     if (identifier.id === null) {
       // TODO potentially this needs to handle merged result
       this.store.identifierCache.updateRecordIdentifier(identifier, {
@@ -1357,16 +1456,16 @@ function resourceIsFullyDeleted(instanceCache, identifier) {
 function preloadData(store, identifier, preload) {
   const jsonPayload = {};
   //TODO(Igor) consider the polymorphic case
-  const schemas = store.getSchemaDefinitionService();
-  const relationships = schemas.relationshipsDefinitionFor(identifier);
+  const schemas = store.schema;
+  const fields = schemas.fields(identifier);
   Object.keys(preload).forEach(key => {
     const preloadValue = preload[key];
-    const relationshipMeta = relationships[key];
-    if (relationshipMeta) {
+    const field = fields.get(key);
+    if (field && (field.kind === 'hasMany' || field.kind === 'belongsTo')) {
       if (!jsonPayload.relationships) {
         jsonPayload.relationships = {};
       }
-      jsonPayload.relationships[key] = preloadRelationship(relationshipMeta, preloadValue);
+      jsonPayload.relationships[key] = preloadRelationship(field, preloadValue);
     } else {
       if (!jsonPayload.attributes) {
         jsonPayload.attributes = {};
@@ -1381,12 +1480,20 @@ function preloadData(store, identifier, preload) {
 function preloadRelationship(schema, preloadValue) {
   const relatedType = schema.type;
   if (schema.kind === 'hasMany') {
-    assert('You need to pass in an array to set a hasMany property on a record', Array.isArray(preloadValue));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error('You need to pass in an array to set a hasMany property on a record');
+      }
+    })(Array.isArray(preloadValue)) : {};
     return {
       data: preloadValue.map(value => _convertPreloadRelationshipToJSON(value, relatedType))
     };
   }
-  assert('You should not pass in an array to set a belongsTo property on a record', !Array.isArray(preloadValue));
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error('You should not pass in an array to set a belongsTo property on a record');
+    }
+  })(!Array.isArray(preloadValue)) : {};
   return {
     data: preloadValue ? _convertPreloadRelationshipToJSON(preloadValue, relatedType) : null
   };
@@ -1415,7 +1522,7 @@ function _clearCaches() {
 
 // if modelFor turns out to be a bottleneck we should replace with a Map
 // and clear it during store teardown.
-const AvailableShims = new WeakMap();
+const AvailableShims = getOrSetGlobal('AvailableShims', new WeakMap());
 function getShimClass(store, modelName) {
   let shims = AvailableShims.get(store);
   if (!shims) {
@@ -1428,15 +1535,6 @@ function getShimClass(store, modelName) {
   }
   return shim;
 }
-function mapFromHash(hash) {
-  const map = new Map();
-  for (const i in hash) {
-    if (Object.prototype.hasOwnProperty.call(hash, i)) {
-      map.set(i, hash[i]);
-    }
-  }
-  return map;
-}
 
 // Mimics the static apis of @ember-data/model
 class ShimModelClass {
@@ -1445,67 +1543,71 @@ class ShimModelClass {
     this.modelName = modelName;
   }
   get fields() {
-    const attrs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
+    const fields = new Map();
+    const fieldSchemas = this.__store.schema.fields({
       type: this.modelName
     });
-    const relationships = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({
-      type: this.modelName
+    fieldSchemas.forEach((schema, key) => {
+      if (schema.kind === 'attribute' || schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        fields.set(key, schema.kind);
+      }
     });
-    const fields = new Map();
-    Object.keys(attrs).forEach(key => fields.set(key, 'attribute'));
-    Object.keys(relationships).forEach(key => fields.set(key, relationships[key].kind));
     return fields;
   }
   get attributes() {
-    const attrs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
+    const attrs = new Map();
+    const fields = this.__store.schema.fields({
       type: this.modelName
     });
-    return mapFromHash(attrs);
+    fields.forEach((schema, key) => {
+      if (schema.kind === 'attribute') {
+        attrs.set(key, schema);
+      }
+    });
+    return attrs;
   }
   get relationshipsByName() {
-    const relationships = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({
+    const rels = new Map();
+    const fields = this.__store.schema.fields({
       type: this.modelName
     });
-    return mapFromHash(relationships);
+    fields.forEach((schema, key) => {
+      if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        rels.set(key, schema);
+      }
+    });
+    return rels;
   }
   eachAttribute(callback, binding) {
-    const attrDefs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
+    this.__store.schema.fields({
       type: this.modelName
-    });
-    Object.keys(attrDefs).forEach(key => {
-      callback.call(binding, key, attrDefs[key]);
+    }).forEach((schema, key) => {
+      if (schema.kind === 'attribute') {
+        callback.call(binding, key, schema);
+      }
     });
   }
   eachRelationship(callback, binding) {
-    const relationshipDefs = this.__store.getSchemaDefinitionService().relationshipsDefinitionFor({
+    this.__store.schema.fields({
       type: this.modelName
-    });
-    Object.keys(relationshipDefs).forEach(key => {
-      callback.call(binding, key, relationshipDefs[key]);
+    }).forEach((schema, key) => {
+      if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        callback.call(binding, key, schema);
+      }
     });
   }
   eachTransformedAttribute(callback, binding) {
-    const attrDefs = this.__store.getSchemaDefinitionService().attributesDefinitionFor({
+    this.__store.schema.fields({
       type: this.modelName
-    });
-    Object.keys(attrDefs).forEach(key => {
-      if (attrDefs[key].type) {
-        callback.call(binding, key, attrDefs[key].type);
+    }).forEach((schema, key) => {
+      if (schema.kind === 'attribute') {
+        const type = schema.type;
+        if (type) callback.call(binding, key, type);
       }
     });
   }
 }
-function _classPrivateFieldBase(receiver, privateKey) {
-  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
-    throw new TypeError("attempted to use private field on non-instance");
-  }
-  return receiver;
-}
-var id = 0;
-function _classPrivateFieldKey(name) {
-  return "__private_" + id++ + "_" + name;
-}
-var _cache = /*#__PURE__*/_classPrivateFieldKey("cache");
+
 /**
  * The CacheManager wraps a Cache enforcing that only
  * the public API surface area is exposed.
@@ -1525,13 +1627,10 @@ var _cache = /*#__PURE__*/_classPrivateFieldKey("cache");
  * @public
  */
 class CacheManager {
+  version = '2';
+  #cache;
   constructor(cache) {
-    this.version = '2';
-    Object.defineProperty(this, _cache, {
-      writable: true,
-      value: void 0
-    });
-    _classPrivateFieldBase(this, _cache)[_cache] = cache;
+    this.#cache = cache;
   }
 
   // Cache Management
@@ -1561,7 +1660,7 @@ class CacheManager {
    * @public
    */
   put(doc) {
-    return _classPrivateFieldBase(this, _cache)[_cache].put(doc);
+    return this.#cache.put(doc);
   }
 
   /**
@@ -1576,7 +1675,7 @@ class CacheManager {
    * @return {void}
    */
   patch(op) {
-    _classPrivateFieldBase(this, _cache)[_cache].patch(op);
+    this.#cache.patch(op);
   }
 
   /**
@@ -1588,7 +1687,7 @@ class CacheManager {
    * @param mutation
    */
   mutate(mutation) {
-    _classPrivateFieldBase(this, _cache)[_cache].mutate(mutation);
+    this.#cache.mutate(mutation);
   }
 
   /**
@@ -1625,7 +1724,7 @@ class CacheManager {
    */
 
   peek(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].peek(identifier);
+    return this.#cache.peek(identifier);
   }
 
   /**
@@ -1638,7 +1737,7 @@ class CacheManager {
    * @public
    */
   peekRequest(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].peekRequest(identifier);
+    return this.#cache.peekRequest(identifier);
   }
 
   /**
@@ -1652,7 +1751,7 @@ class CacheManager {
    * @return {void | string[]} if `hasRecord` is true then calculated key changes should be returned
    */
   upsert(identifier, data, hasRecord) {
-    return _classPrivateFieldBase(this, _cache)[_cache].upsert(identifier, data, hasRecord);
+    return this.#cache.upsert(identifier, data, hasRecord);
   }
 
   // Cache Forking Support
@@ -1670,7 +1769,7 @@ class CacheManager {
    * @return Promise<Cache>
    */
   fork() {
-    return _classPrivateFieldBase(this, _cache)[_cache].fork();
+    return this.#cache.fork();
   }
 
   /**
@@ -1686,7 +1785,7 @@ class CacheManager {
    * @return Promise<void>
    */
   merge(cache) {
-    return _classPrivateFieldBase(this, _cache)[_cache].merge(cache);
+    return this.#cache.merge(cache);
   }
 
   /**
@@ -1723,7 +1822,7 @@ class CacheManager {
    * @public
    */
   diff() {
-    return _classPrivateFieldBase(this, _cache)[_cache].diff();
+    return this.#cache.diff();
   }
 
   // SSR Support
@@ -1739,7 +1838,7 @@ class CacheManager {
    * @public
    */
   dump() {
-    return _classPrivateFieldBase(this, _cache)[_cache].dump();
+    return this.#cache.dump();
   }
 
   /**
@@ -1760,7 +1859,7 @@ class CacheManager {
    * @public
    */
   hydrate(stream) {
-    return _classPrivateFieldBase(this, _cache)[_cache].hydrate(stream);
+    return this.#cache.hydrate(stream);
   }
 
   // Cache
@@ -1781,7 +1880,7 @@ class CacheManager {
    * @param options
    */
   clientDidCreate(identifier, options) {
-    return _classPrivateFieldBase(this, _cache)[_cache].clientDidCreate(identifier, options);
+    return this.#cache.clientDidCreate(identifier, options);
   }
 
   /**
@@ -1793,7 +1892,7 @@ class CacheManager {
    * @param identifier
    */
   willCommit(identifier, context) {
-    _classPrivateFieldBase(this, _cache)[_cache].willCommit(identifier, context);
+    this.#cache.willCommit(identifier, context);
   }
 
   /**
@@ -1806,7 +1905,7 @@ class CacheManager {
    * @param data
    */
   didCommit(identifier, result) {
-    return _classPrivateFieldBase(this, _cache)[_cache].didCommit(identifier, result);
+    return this.#cache.didCommit(identifier, result);
   }
 
   /**
@@ -1819,7 +1918,7 @@ class CacheManager {
    * @param errors
    */
   commitWasRejected(identifier, errors) {
-    _classPrivateFieldBase(this, _cache)[_cache].commitWasRejected(identifier, errors);
+    this.#cache.commitWasRejected(identifier, errors);
   }
 
   /**
@@ -1831,7 +1930,7 @@ class CacheManager {
    * @param identifier
    */
   unloadRecord(identifier) {
-    _classPrivateFieldBase(this, _cache)[_cache].unloadRecord(identifier);
+    this.#cache.unloadRecord(identifier);
   }
 
   // Granular Resource Data APIs
@@ -1847,7 +1946,7 @@ class CacheManager {
    * @return {unknown}
    */
   getAttr(identifier, propertyName) {
-    return _classPrivateFieldBase(this, _cache)[_cache].getAttr(identifier, propertyName);
+    return this.#cache.getAttr(identifier, propertyName);
   }
 
   /**
@@ -1860,7 +1959,7 @@ class CacheManager {
    * @param value
    */
   setAttr(identifier, propertyName, value) {
-    _classPrivateFieldBase(this, _cache)[_cache].setAttr(identifier, propertyName, value);
+    this.#cache.setAttr(identifier, propertyName, value);
   }
 
   /**
@@ -1872,7 +1971,7 @@ class CacheManager {
    * @return
    */
   changedAttrs(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].changedAttrs(identifier);
+    return this.#cache.changedAttrs(identifier);
   }
 
   /**
@@ -1884,7 +1983,7 @@ class CacheManager {
    * @return {boolean}
    */
   hasChangedAttrs(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].hasChangedAttrs(identifier);
+    return this.#cache.hasChangedAttrs(identifier);
   }
 
   /**
@@ -1896,7 +1995,7 @@ class CacheManager {
    * @return the names of attributes that were restored
    */
   rollbackAttrs(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].rollbackAttrs(identifier);
+    return this.#cache.rollbackAttrs(identifier);
   }
 
   // Relationships
@@ -1930,7 +2029,7 @@ class CacheManager {
    * @return {Map<string, RelationshipDiff>}
    */
   changedRelationships(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].changedRelationships(identifier);
+    return this.#cache.changedRelationships(identifier);
   }
 
   /**
@@ -1942,7 +2041,7 @@ class CacheManager {
    * @return {boolean}
    */
   hasChangedRelationships(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].hasChangedRelationships(identifier);
+    return this.#cache.hasChangedRelationships(identifier);
   }
 
   /**
@@ -1958,7 +2057,7 @@ class CacheManager {
    * @return {string[]} the names of relationships that were restored
    */
   rollbackRelationships(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].rollbackRelationships(identifier);
+    return this.#cache.rollbackRelationships(identifier);
   }
 
   /**
@@ -1971,7 +2070,7 @@ class CacheManager {
    * @return resource relationship object
    */
   getRelationship(identifier, propertyName) {
-    return _classPrivateFieldBase(this, _cache)[_cache].getRelationship(identifier, propertyName);
+    return this.#cache.getRelationship(identifier, propertyName);
   }
 
   // Resource State
@@ -1987,7 +2086,7 @@ class CacheManager {
    * @param isDeleted
    */
   setIsDeleted(identifier, isDeleted) {
-    _classPrivateFieldBase(this, _cache)[_cache].setIsDeleted(identifier, isDeleted);
+    this.#cache.setIsDeleted(identifier, isDeleted);
   }
 
   /**
@@ -1999,7 +2098,7 @@ class CacheManager {
    * @return
    */
   getErrors(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].getErrors(identifier);
+    return this.#cache.getErrors(identifier);
   }
 
   /**
@@ -2011,7 +2110,7 @@ class CacheManager {
    * @return {boolean}
    */
   isEmpty(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].isEmpty(identifier);
+    return this.#cache.isEmpty(identifier);
   }
 
   /**
@@ -2024,7 +2123,7 @@ class CacheManager {
    * @return {boolean}
    */
   isNew(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].isNew(identifier);
+    return this.#cache.isNew(identifier);
   }
 
   /**
@@ -2037,7 +2136,7 @@ class CacheManager {
    * @return {boolean}
    */
   isDeleted(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].isDeleted(identifier);
+    return this.#cache.isDeleted(identifier);
   }
 
   /**
@@ -2050,13 +2149,14 @@ class CacheManager {
    * @return {boolean}
    */
   isDeletionCommitted(identifier) {
-    return _classPrivateFieldBase(this, _cache)[_cache].isDeletionCommitted(identifier);
+    return this.#cache.isDeletionCommitted(identifier);
   }
 }
 
 /**
  * @module @ember-data/store
  */
+// eslint-disable-next-line no-restricted-imports
 let tokenId = 0;
 const CacheOperations = new Set(['added', 'removed', 'state', 'updated']);
 function isCacheOperationValue(value) {
@@ -2068,7 +2168,7 @@ function runLoopIsFlushing() {
 }
 function _unsubscribe(tokens, token, cache) {
   const identifier = tokens.get(token);
-  if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
+  if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS)) {
     if (!identifier) {
       // eslint-disable-next-line no-console
       console.log('Passed unknown unsubscribe token to unsubscribe', identifier);
@@ -2130,13 +2230,17 @@ class NotificationManager {
    */
 
   subscribe(identifier, callback) {
-    assert(`Expected to receive a stable Identifier to subscribe to`, identifier === 'resource' || identifier === 'document' || isStableIdentifier(identifier) || isDocumentIdentifier(identifier));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        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);
     }
-    const unsubToken = macroCondition(getOwnConfig().env.DEBUG) ? {
+    const unsubToken = macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? {
       _tokenRef: tokenId++
     } : {};
     map.set(unsubToken, callback);
@@ -2169,15 +2273,19 @@ class NotificationManager {
    */
 
   notify(identifier, value, key) {
-    assert(`Notify does not accept a key argument for the namespace '${value}'. Received key '${key || ''}'.`, !key || value === 'attributes' || value === 'relationships');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Notify does not accept a key argument for the namespace '${value}'. Received key '${key || ''}'.`);
+      }
+    })(!key || value === 'attributes' || value === 'relationships') : {};
     if (!isStableIdentifier(identifier) && !isDocumentIdentifier(identifier)) {
-      if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
+      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);
       }
       return false;
     }
-    if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS)) {
       // eslint-disable-next-line no-console
       console.log(`Buffering Notify: ${String(identifier.lid)}\t${value}\t${key || ''}`);
     }
@@ -2224,7 +2332,7 @@ class NotificationManager {
     this._onFlushCB = undefined;
   }
   _flushNotification(identifier, value, key) {
-    if (macroCondition(getOwnConfig().debug.LOG_NOTIFICATIONS)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS)) {
       // eslint-disable-next-line no-console
       console.log(`Notifying: ${String(identifier)}\t${value}\t${key || ''}`);
     }
@@ -2254,30 +2362,139 @@ class NotificationManager {
     this._cache.clear();
   }
 }
-function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
-  var desc = {};
-  Object.keys(descriptor).forEach(function (key) {
-    desc[key] = descriptor[key];
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/*
+  We redefine Proxy because the native Proxy type treats the `target` and
+  `receiver` as the same type incorrectly.
+
+  We ported this from Typescript's own Proxy types on 3/10/2024.
+*/
+
+const NativeProxy = Proxy;
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
   });
-  desc.enumerable = !!desc.enumerable;
-  desc.configurable = !!desc.configurable;
-  if ('value' in desc || desc.initializer) {
-    desc.writable = true;
-  }
-  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
-    return decorator(target, property, desc) || desc;
-  }, desc);
-  if (context && desc.initializer !== void 0) {
-    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
-    desc.initializer = undefined;
+};
+
+// src/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  c: () => decorateClass,
+  f: () => decorateFieldV1,
+  g: () => decorateFieldV2,
+  i: () => initializeDeferredDecorator,
+  m: () => decorateMethodV1,
+  n: () => decorateMethodV2,
+  p: () => decoratePOJO
+});
+var deferred = /* @__PURE__ */new WeakMap();
+function deferDecorator(proto, prop, desc) {
+  let map = deferred.get(proto);
+  if (!map) {
+    map = /* @__PURE__ */new Map();
+    deferred.set(proto, map);
+  }
+  map.set(prop, desc);
+}
+function findDeferredDecorator(target, prop) {
+  let cursor = target.prototype;
+  while (cursor) {
+    let desc = deferred.get(cursor)?.get(prop);
+    if (desc) {
+      return desc;
+    }
+    cursor = cursor.prototype;
+  }
+}
+function decorateFieldV1(target, prop, decorators, initializer) {
+  return decorateFieldV2(target.prototype, prop, decorators, initializer);
+}
+function decorateFieldV2(prototype, prop, decorators, initializer) {
+  let desc = {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  };
+  if (initializer) {
+    desc.initializer = initializer;
+  }
+  for (let decorator of decorators) {
+    desc = decorator(prototype, prop, desc) || desc;
   }
   if (desc.initializer === void 0) {
-    Object.defineProperty(target, property, desc);
-    desc = null;
+    Object.defineProperty(prototype, prop, desc);
+  } else {
+    deferDecorator(prototype, prop, desc);
   }
-  return desc;
 }
-var _class;
+function decorateMethodV1({
+  prototype
+}, prop, decorators) {
+  return decorateMethodV2(prototype, prop, decorators);
+}
+function decorateMethodV2(prototype, prop, decorators) {
+  const origDesc = Object.getOwnPropertyDescriptor(prototype, prop);
+  let desc = {
+    ...origDesc
+  };
+  for (let decorator of decorators) {
+    desc = decorator(prototype, prop, desc) || desc;
+  }
+  if (desc.initializer !== void 0) {
+    desc.value = desc.initializer ? desc.initializer.call(prototype) : void 0;
+    desc.initializer = void 0;
+  }
+  Object.defineProperty(prototype, prop, desc);
+}
+function initializeDeferredDecorator(target, prop) {
+  let desc = findDeferredDecorator(target.constructor, prop);
+  if (desc) {
+    Object.defineProperty(target, prop, {
+      enumerable: desc.enumerable,
+      configurable: desc.configurable,
+      writable: desc.writable,
+      value: desc.initializer ? desc.initializer.call(target) : void 0
+    });
+  }
+}
+function decorateClass(target, decorators) {
+  return decorators.reduce((accum, decorator) => decorator(accum) || accum, target);
+}
+function decoratePOJO(pojo, decorated) {
+  for (let [type, prop, decorators] of decorated) {
+    if (type === "field") {
+      decoratePojoField(pojo, prop, decorators);
+    } else {
+      decorateMethodV2(pojo, prop, decorators);
+    }
+  }
+  return pojo;
+}
+function decoratePojoField(pojo, prop, decorators) {
+  let desc = {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: () => Object.getOwnPropertyDescriptor(pojo, prop)?.value
+  };
+  for (let decorator of decorators) {
+    desc = decorator(pojo, prop, desc) || desc;
+  }
+  if (desc.initializer) {
+    desc.value = desc.initializer.call(pojo);
+    delete desc.initializer;
+  }
+  Object.defineProperty(pojo, prop, desc);
+}
+
+/**
+  @module @ember-data/store
+*/
 const ARRAY_GETTER_METHODS = new Set([Symbol.iterator, 'concat', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'flat', 'flatMap', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'map', 'reduce', 'reduceRight', 'slice', 'some', 'values']);
 const ARRAY_SETTER_METHODS = new Set(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
 const SYNC_PROPS = new Set(['[]', 'length', 'links', 'meta']);
@@ -2290,11 +2507,11 @@ function isArraySetter(prop) {
 function isSelfProp(self, prop) {
   return prop in self;
 }
-const ARRAY_SIGNAL = Symbol('#signal');
-const SOURCE = Symbol('#source');
-const MUTATE = Symbol('#update');
-const NOTIFY = Symbol('#notify');
-const IS_COLLECTION = Symbol.for('Collection');
+const ARRAY_SIGNAL = getOrSetGlobal('#signal', Symbol('#signal'));
+const SOURCE = getOrSetGlobal('#source', Symbol('#source'));
+const MUTATE = getOrSetGlobal('#update', Symbol('#update'));
+const NOTIFY = getOrSetGlobal('#notify', Symbol('#notify'));
+const IS_COLLECTION = getOrSetGlobal('IS_COLLECTION', Symbol.for('Collection'));
 function notifyArray(arr) {
   addToTransaction(arr[ARRAY_SIGNAL]);
 }
@@ -2310,7 +2527,11 @@ function safeForEach(instance, arr, store, callback, target) {
   }
   // clone to prevent mutation
   arr = arr.slice();
-  assert('`forEach` expects a function as first argument.', typeof callback === 'function');
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error('`forEach` expects a function as first argument.');
+    }
+  })(typeof callback === 'function') : {};
 
   // because we retrieveLatest above we need not worry if array is mutated during iteration
   // by unloadRecord/rollbackAttributes
@@ -2336,7 +2557,28 @@ function safeForEach(instance, arr, store, callback, target) {
   @class RecordArray
   @public
 */
-let IdentifierArray = (_class = class IdentifierArray {
+
+class IdentifierArray {
+  /**
+    The flag to signal a `RecordArray` is currently loading data.
+    Example
+    ```javascript
+    let people = store.peekAll('person');
+    people.isUpdating; // false
+    people.update();
+    people.isUpdating; // true
+    ```
+    @property isUpdating
+    @public
+    @type Boolean
+  */
+
+  isLoaded = true;
+  isDestroying = false;
+  isDestroyed = false;
+  _updatingPromise = null;
+  [IS_COLLECTION] = true;
+  [SOURCE];
   [NOTIFY]() {
     notifyArray(this);
   }
@@ -2361,29 +2603,13 @@ let IdentifierArray = (_class = class IdentifierArray {
   get length() {
     return this[SOURCE].length;
   }
+  static {
+    decorateMethodV2(this.prototype, "length", [compat]);
+  }
   set length(value) {
     this[SOURCE].length = value;
   }
   constructor(options) {
-    /**
-      The flag to signal a `RecordArray` is currently loading data.
-      Example
-      ```javascript
-      let people = store.peekAll('person');
-      people.isUpdating; // false
-      people.update();
-      people.isUpdating; // true
-      ```
-      @property isUpdating
-      @public
-      @type Boolean
-    */
-    this.isLoaded = true;
-    this.isDestroying = false;
-    this.isDestroyed = false;
-    this._updatingPromise = null;
-    this[IS_COLLECTION] = true;
-    this[SOURCE] = void 0;
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
     this.modelName = options.type;
@@ -2404,7 +2630,7 @@ let IdentifierArray = (_class = class IdentifierArray {
     // we track all mutations within the call
     // and forward them as one
 
-    const proxy = new Proxy(this[SOURCE], {
+    const proxy = new NativeProxy(this[SOURCE], {
       get(target, prop, receiver) {
         const index = convertToInt(prop);
         if (_SIGNAL.shouldReset && (index !== null || SYNC_PROPS.has(prop) || isArrayGetter(prop))) {
@@ -2455,11 +2681,19 @@ let IdentifierArray = (_class = class IdentifierArray {
               // array functions must run through Reflect to work properly
               // binding via other means will not work.
               if (!options.allowMutation) {
-                assert(`Mutating this array of records via ${String(prop)} is not allowed.`, options.allowMutation);
+                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                  if (!test) {
+                    throw new Error(`Mutating this array of records via ${String(prop)} is not allowed.`);
+                  }
+                })(options.allowMutation) : {};
                 return;
               }
               const args = Array.prototype.slice.call(arguments);
-              assert(`Cannot start a new array transaction while a previous transaction is underway`, !transaction);
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                if (!test) {
+                  throw new Error(`Cannot start a new array transaction while a previous transaction is underway`);
+                }
+              })(!transaction) : {};
               transaction = true;
               const result = self[MUTATE](target, receiver, prop, args, _SIGNAL);
               transaction = false;
@@ -2501,7 +2735,11 @@ let IdentifierArray = (_class = class IdentifierArray {
           } else if (transaction) {
             return Reflect.set(target, prop, value);
           } else {
-            assert(`unexpected length set`);
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              {
+                throw new Error(`unexpected length set`);
+              }
+            })() : {};
           }
         }
         if (prop === 'links') {
@@ -2524,23 +2762,36 @@ let IdentifierArray = (_class = class IdentifierArray {
         if (index === null || index > target.length) {
           if (index !== null && transaction) {
             const identifier = recordIdentifierFor(value);
-            assert(`Cannot set index ${index} past the end of the array.`, isStableIdentifier(identifier));
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              if (!test) {
+                throw new Error(`Cannot set index ${index} past the end of the array.`);
+              }
+            })(isStableIdentifier(identifier)) : {};
             target[index] = identifier;
             return true;
           } else if (isSelfProp(self, prop)) {
+            // @ts-expect-error not all properties are indeces and we can't safely cast
             self[prop] = value;
             return true;
           }
           return false;
         }
         if (!options.allowMutation) {
-          assert(`Mutating ${String(prop)} on this RecordArray is not allowed.`, options.allowMutation);
+          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+            if (!test) {
+              throw new Error(`Mutating ${String(prop)} on this Array is not allowed.`);
+            }
+          })(options.allowMutation) : {};
           return false;
         }
         const original = target[index];
         const newIdentifier = extractIdentifierFromRecord$1(value);
         target[index] = newIdentifier;
-        assert(`Expected a record`, isStableIdentifier(newIdentifier));
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`Expected a record`);
+          }
+        })(isStableIdentifier(newIdentifier)) : {};
         // We generate "transactions" whenever a setter method on the array
         // is called and might bulk update multiple array cells. Fundamentally,
         // all array operations decompose into individual cell replacements.
@@ -2565,7 +2816,11 @@ let IdentifierArray = (_class = class IdentifierArray {
         return true;
       },
       deleteProperty(target, prop) {
-        assert(`Deleting keys on managed arrays is disallowed`, transaction);
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`Deleting keys on managed arrays is disallowed`);
+          }
+        })(transaction) : {};
         if (!transaction) {
           return false;
         }
@@ -2613,11 +2868,19 @@ let IdentifierArray = (_class = class IdentifierArray {
   }
 
   /*
-    Update this RecordArray and return a promise which resolves once the update
+    Update this Array and return a promise which resolves once the update
     is finished.
    */
   _update() {
-    assert(`_update cannot be used with this array`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`_update cannot be used with this array`);
+      }
+    })(this.modelName) : {};
+    // @ts-expect-error typescript is unable to handle the complexity of
+    //   T = unknown, modelName = string
+    //   T extends TypedRecordInstance, modelName = TypeFromInstance<T>
+    // both being valid options to pass through here.
     return this.store.findAll(this.modelName, {
       reload: true
     });
@@ -2642,7 +2905,9 @@ let IdentifierArray = (_class = class IdentifierArray {
     const promise = Promise.all(this.map(record => this.store.saveRecord(record))).then(() => this);
     return promise;
   }
-}, _applyDecoratedDescriptor(_class.prototype, "length", [compat], Object.getOwnPropertyDescriptor(_class.prototype, "length"), _class.prototype), _class); // this will error if someone tries to call
+}
+
+// this will error if someone tries to call
 // A(identifierArray) since it is not configurable
 // which is preferable to the `meta` override we used
 // before which required importing all of Ember
@@ -2657,9 +2922,9 @@ compat(desc);
 Object.defineProperty(IdentifierArray.prototype, '[]', desc);
 defineSignal(IdentifierArray.prototype, 'isUpdating', false);
 class Collection extends IdentifierArray {
+  query = null;
   constructor(options) {
     super(options);
-    this.query = null;
     this.query = options.query || null;
     this.isLoaded = options.isLoaded || false;
   }
@@ -2670,8 +2935,20 @@ class Collection extends IdentifierArray {
     } = this;
 
     // TODO save options from initial request?
-    assert(`update cannot be used with this array`, this.modelName);
-    assert(`update cannot be used with no query`, query);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`update cannot be used with this array`);
+      }
+    })(this.modelName) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`update cannot be used with no query`);
+      }
+    })(query) : {};
+    // @ts-expect-error typescript is unable to handle the complexity of
+    //   T = unknown, modelName = string
+    //   T extends TypedRecordInstance, modelName = TypeFromInstance<T>
+    // both being valid options to pass through here.
     const promise = store.query(this.modelName, query, {
       _recordArray: this
     });
@@ -2690,14 +2967,18 @@ Collection.prototype.query = null;
 // Object.setPrototypeOf(IdentifierArray.prototype, Array.prototype);
 
 function assertRecordPassedToHasMany(record) {
-  assert(`All elements of a hasMany relationship must be instances of Model, you passed $${typeof record}`, function () {
+  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 extractIdentifierFromRecord$1(record) {
   if (!record) {
@@ -2710,7 +2991,7 @@ function extractIdentifierFromRecord$1(record) {
 /**
   @module @ember-data/store
 */
-const FAKE_ARR = {};
+const FAKE_ARR = getOrSetGlobal('FAKE_ARR', {});
 const SLICE_BATCH_SIZE = 1200;
 /**
  * This is a clever optimization.
@@ -3058,9 +3339,10 @@ function sync(array, changes, arraySet) {
 /**
  * @module @ember-data/store
  */
-const Touching = Symbol('touching');
-const RequestPromise = Symbol('promise');
-const EMPTY_ARR = macroCondition(getOwnConfig().env.DEBUG) ? Object.freeze([]) : [];
+
+const Touching = getOrSetGlobal('Touching', Symbol('touching'));
+const RequestPromise = getOrSetGlobal('RequestPromise', Symbol('promise'));
+const EMPTY_ARR = macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? Object.freeze([]) : [];
 function hasRecordIdentifier(op) {
   return 'recordIdentifier' in op;
 }
@@ -3073,12 +3355,12 @@ function hasRecordIdentifier(op) {
  * @public
  */
 class RequestStateService {
+  _pending = new Map();
+  _done = new Map();
+  _subscriptions = new Map();
+  _toFlush = [];
+  _store;
   constructor(store) {
-    this._pending = new Map();
-    this._done = new Map();
-    this._subscriptions = new Map();
-    this._toFlush = [];
-    this._store = void 0;
     this._store = store;
   }
   _clearEntries(identifier) {
@@ -3131,7 +3413,11 @@ class RequestStateService {
         throw error;
       });
     }
-    assert(`Expected a well formed  query`);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      {
+        throw new Error(`Expected a well formed  query`);
+      }
+    })() : {};
   }
   _triggerSubscriptions(req) {
     if (req.state === 'pending') {
@@ -3264,8 +3550,16 @@ function constructResource(type, id, lid) {
     if ('id' in resource) {
       resource.id = coerceId(resource.id);
     }
-    assert('Expected either id or lid to be a valid string', 'id' in resource && isNonEmptyString(resource.id) || isNonEmptyString(resource.lid));
-    assert('if id is present, the type must be a string', !('id' in resource) || typeof resource.type === 'string');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error('Expected either id or lid to be a valid string');
+      }
+    })('id' in resource && isNonEmptyString(resource.id) || isNonEmptyString(resource.lid)) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error('if id is present, the type must be a string');
+      }
+    })(!('id' in resource) || typeof resource.type === 'string') : {};
     return resource;
   } else {
     const trueId = coerceId(id);
@@ -3277,7 +3571,11 @@ function constructResource(type, id, lid) {
       }
       throw new Error('Expected either id or lid to be a valid string');
     }
-    assert('type must be a string', typeof type === 'string');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error('type must be a string');
+      }
+    })(typeof type === 'string') : {};
     if (isNonEmptyString(lid)) {
       return {
         type,
@@ -3297,6 +3595,26 @@ function constructResource(type, id, lid) {
  */
 // this import location is deprecated but breaks in 4.8 and older
 
+// `AwaitedKeys` is needed here to resolve any promise types like `PromiseBelongsTo`.
+
+/**
+ * Currently only records that extend object can be created via
+ * store.createRecord. This is a limitation of the current API,
+ * but can be worked around by creating a new identifier, running
+ * the cache.clientDidCreate method, and then peeking the record
+ * for the identifier.
+ *
+ * To assign primary key to a record during creation, only `id` will
+ * work correctly for `store.createRecord`, other primary key may be
+ * handled by updating the record after creation or using the flow
+ * described above.
+ *
+ * TODO: These are limitations we want to (and can) address. If you
+ * have need of lifting these limitations, please open an issue.
+ *
+ * @typedoc
+ */
+
 /**
  * A Store coordinates interaction between your application, a [Cache](https://api.emberjs.com/ember-data/release/classes/%3CInterface%3E%20Cache),
  * and sources of data (such as your API or a local persistence layer)
@@ -3308,18 +3626,47 @@ function constructResource(type, id, lid) {
  * export default class extends Store {}
  * ```
  *
- * Most Ember applications will only have a single `Store` configured as a Service
+ * Most Applications will only have a single `Store` configured as a Service
  * in this manner. However, setting up multiple stores is possible, including using
- * each as a unique service.
+ * each as a unique service or within a specific context.
  *
 
   @class Store
   @public
 */
-
-// @ts-expect-error
-
-class Store extends EmberObject {
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+const EmptyClass = class {
+  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+  constructor(args) {}
+};
+const BaseClass = macroCondition(dependencySatisfies('ember-source', '*')) ? macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_STORE_EXTENDS_EMBER_OBJECT) ? importSync('@ember/object') : EmptyClass : EmptyClass;
+if (BaseClass !== EmptyClass) {
+  deprecate(`The Store class extending from EmberObject is deprecated.
+Please remove usage of EmberObject APIs and mark your class as not requiring it.
+
+To mark the class as no longer extending from EmberObject, in ember-cli-build.js
+set the following config:
+
+\`\`\`js
+const app = new EmberApp(defaults, {
+  emberData: {
+    deprecations: {
+      DEPRECATE_STORE_EXTENDS_EMBER_OBJECT: false
+    }
+  }
+});
+\`\`\`
+`, false, {
+    id: 'ember-data:deprecate-store-extends-ember-object',
+    until: '6.0',
+    for: 'ember-data',
+    since: {
+      available: '5.4',
+      enabled: '5.4'
+    }
+  });
+}
+class Store extends BaseClass {
   /**
    * Provides access to the NotificationManager associated
    * with this Store instance.
@@ -3342,7 +3689,10 @@ class Store extends EmberObject {
    * @public
    */
   get schema() {
-    return this.getSchemaDefinitionService();
+    if (!this._schema) {
+      this._schema = this.createSchemaService();
+    }
+    return this._schema;
   }
 
   /**
@@ -3368,7 +3718,7 @@ class Store extends EmberObject {
    * ```ts
    * import Store, { CacheHandler } from '@ember-data/store';
    * import RequestManager from '@ember-data/request';
-   * import Fetch from '@ember/data/request/fetch';
+   * import Fetch from '@ember-data/request/fetch';
    *
    * class extends Store {
    *   constructor() {
@@ -3385,7 +3735,7 @@ class Store extends EmberObject {
    */
 
   /**
-   * A Property which an App may set to provide a Lifetimes Service
+   * A Property which an App may set to provide a CachePolicy
    * to control when a cached request becomes stale.
    *
    * Note, when defined, these methods will only be invoked if a
@@ -3411,7 +3761,7 @@ class Store extends EmberObject {
    * ```
    *
    * @public
-   * @property {LivetimesService|undefined} lifetimes
+   * @property {CachePolicy|undefined} lifetimes
    */
 
   // Private
@@ -3436,7 +3786,6 @@ class Store extends EmberObject {
     @private
   */
   constructor(createArgs) {
-    // @ts-expect-error ember-source types improperly expect createArgs to be `Owner`
     super(createArgs);
     Object.assign(this, createArgs);
     this.identifierCache = new IdentifierCache();
@@ -3455,9 +3804,13 @@ class Store extends EmberObject {
     this.isDestroyed = false;
   }
   _run(cb) {
-    assert(`EmberData should never encounter a nested run`, !this._cbs);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`EmberData should never encounter a nested run`);
+      }
+    })(!this._cbs) : {};
     const _cbs = this._cbs = {};
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       try {
         cb();
         if (_cbs.coalesce) {
@@ -3494,8 +3847,16 @@ class Store extends EmberObject {
     }
   }
   _schedule(name, cb) {
-    assert(`EmberData expects to schedule only when there is an active run`, !!this._cbs);
-    assert(`EmberData expects only one flush per queue name, cannot schedule ${name}`, !this._cbs[name]);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`EmberData expects to schedule only when there is an active run`);
+      }
+    })(!!this._cbs) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`EmberData expects only one flush per queue name, cannot schedule ${name}`);
+      }
+    })(!this._cbs[name]) : {};
     this._cbs[name] = cb;
   }
 
@@ -3514,7 +3875,7 @@ class Store extends EmberObject {
     return this._requestCache;
   }
   _getAllPending() {
-    if (macroCondition(getOwnConfig().env.TESTING)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
       const all = [];
       const pending = this._requestCache._pending;
       pending.forEach(requests => {
@@ -3539,7 +3900,7 @@ class Store extends EmberObject {
    * and document cached.
    *
    * The cache key used is `requestConfig.cacheOptions.key`
-   * if present, falling back to `requestconfig.url`.
+   * if present, falling back to `requestConfig.url`.
    *
    * Params are not serialized as part of the cache-key, so
    * either ensure they are already in the url or utilize
@@ -3557,7 +3918,7 @@ class Store extends EmberObject {
    * When a cache-key is determined, the request may fulfill
    * from cache provided the cache is not stale.
    *
-   * Cache staleness is determined by the configured LifetimesService
+   * Cache staleness is determined by the configured CachePolicy
    * with priority given to the `cacheOptions.reload` and
    * `cacheOptions.backgroundReload` on the request if present.
    *
@@ -3592,12 +3953,12 @@ class Store extends EmberObject {
       const identifierCache = this.identifierCache;
       opts.records = requestConfig.records.map(r => identifierCache.getOrCreateRecordIdentifier(r));
     }
-    if (macroCondition(getOwnConfig().env.TESTING)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
       if (this.DISABLE_WAITER) {
         opts.disableTestWaiter = typeof requestConfig.disableTestWaiter === 'boolean' ? requestConfig.disableTestWaiter : true;
       }
     }
-    if (macroCondition(getOwnConfig().debug.LOG_REQUESTS)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_REQUESTS)) {
       let options;
       try {
         options = JSON.parse(JSON.stringify(requestConfig));
@@ -3607,9 +3968,10 @@ class Store extends EmberObject {
       // eslint-disable-next-line no-console
       console.log(`request: [[START]] ${requestConfig.op && !requestConfig.url ? '(LEGACY) ' : ''}${requestConfig.op || '<unknown operation>'} ${requestConfig.url || '<empty url>'}  ${requestConfig.method || '<empty method>'}`, options);
     }
-    const future = this.requestManager.request(Object.assign(requestConfig, opts));
+    const request = Object.assign({}, requestConfig, opts);
+    const future = this.requestManager.request(request);
     future.onFinalize(() => {
-      if (macroCondition(getOwnConfig().debug.LOG_REQUESTS)) {
+      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>'}`);
       }
@@ -3628,7 +3990,7 @@ class Store extends EmberObject {
    * a resource.
    *
    * This hook can be used to select or instantiate any desired
-   * mechanism of presentating cache data to the ui for access
+   * mechanism of presenting cache data to the ui for access
    * mutation, and interaction.
    *
    * @method instantiateRecord (hook)
@@ -3652,134 +4014,7 @@ class Store extends EmberObject {
    */
 
   /**
-   * Provides access to the SchemaDefinitionService instance
-   * for this Store instance.
-   *
-   * The SchemaDefinitionService can be used to query for
-   * information about the schema of a resource.
-   *
-   * @method getSchemaDefinitionService
-   * @public
-   */
-  getSchemaDefinitionService() {
-    assert(`You must registerSchemaDefinitionService with the store to use custom model classes`, this._schema);
-    return this._schema;
-  }
-
-  /**
-   * DEPRECATED - Use `registerSchema` instead.
-   *
-   * Allows an app to register a custom SchemaService
-   * for use when information about a resource's schema needs
-   * to be queried.
-   *
-   * This method can only be called more than once, but only one schema
-   * definition service may exist. Therefore if you wish to chain services
-   * you must lookup the existing service and close over it with the new
-   * service by accessing `store.schema` prior to registration.
-   *
-   * For Example:
-   *
-   * ```ts
-   * import Store from '@ember-data/store';
-   *
-   * class SchemaDelegator {
-   *   constructor(schema) {
-   *     this._schema = schema;
-   *   }
-   *
-   *   doesTypeExist(type: string): boolean {
-   *     if (AbstractSchemas.has(type)) {
-   *       return true;
-   *     }
-   *     return this._schema.doesTypeExist(type);
-   *   }
-   *
-   *   attributesDefinitionFor(identifier: RecordIdentifier | { type: string }): AttributesSchema {
-   *     return this._schema.attributesDefinitionFor(identifier);
-   *   }
-   *
-   *   relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
-   *     const schema = AbstractSchemas.get(identifier.type);
-   *     return schema || this._schema.relationshipsDefinitionFor(identifier);
-   *   }
-   * }
-   *
-   * export default class extends Store {
-   *   constructor(...args) {
-   *     super(...args);
-   *
-   *     const schema = this.schema;
-   *     this.registerSchemaDefinitionService(new SchemaDelegator(schema));
-   *   }
-   * }
-   * ```
-   *
-   * @method registerSchemaDefinitionService
-   * @param {SchemaService} schema
-   * @deprecated
-   * @public
-   */
-  registerSchemaDefinitionService(schema) {
-    this._schema = schema;
-  }
-  /**
-   * Allows an app to register a custom SchemaService
-   * for use when information about a resource's schema needs
-   * to be queried.
-   *
-   * This method can only be called more than once, but only one schema
-   * definition service may exist. Therefore if you wish to chain services
-   * you must lookup the existing service and close over it with the new
-   * service by accessing `store.schema` prior to registration.
-   *
-   * For Example:
-   *
-   * ```ts
-   * import Store from '@ember-data/store';
-   *
-   * class SchemaDelegator {
-   *   constructor(schema) {
-   *     this._schema = schema;
-   *   }
-   *
-   *   doesTypeExist(type: string): boolean {
-   *     if (AbstractSchemas.has(type)) {
-   *       return true;
-   *     }
-   *     return this._schema.doesTypeExist(type);
-   *   }
-   *
-   *   attributesDefinitionFor(identifier: RecordIdentifier | { type: string }): AttributesSchema {
-   *     return this._schema.attributesDefinitionFor(identifier);
-   *   }
-   *
-   *   relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
-   *     const schema = AbstractSchemas.get(identifier.type);
-   *     return schema || this._schema.relationshipsDefinitionFor(identifier);
-   *   }
-   * }
-   *
-   * export default class extends Store {
-   *   constructor(...args) {
-   *     super(...args);
-   *
-   *     const schema = this.schema;
-   *     this.registerSchema(new SchemaDelegator(schema));
-   *   }
-   * }
-   * ```
-   *
-   * @method registerSchema
-   * @param {SchemaService} schema
-   * @public
-   */
-  registerSchema(schema) {
-    this._schema = schema;
-  }
-
-  /**
-    Returns the schema for a particular `modelName`.
+    Returns the schema for a particular resource type (modelName).
      When used with Model from @ember-data/model the return is the model class,
     but this is not guaranteed.
      If looking to query attribute or relationship information it is
@@ -3793,17 +4028,29 @@ class Store extends EmberObject {
     for example.
      @method modelFor
     @public
-    @param {String} type
+    @deprecated
+    @param {string} type
     @return {ModelSchema}
     */
-  // TODO @deprecate in favor of schema APIs, requires adapter/serializer overhaul or replacement
 
   modelFor(type) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    // FIXME add deprecation and deprecation stripping
+    // FIXME/TODO update RFC to remove this method
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyedStoreOnly(this, 'modelFor');
     }
-    assert(`You need to pass <type> to the store's modelFor method`, typeof type === 'string' && type.length);
-    assert(`No model was found for '${type}' and no schema handles the type`, this.getSchemaDefinitionService().doesTypeExist(type));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass <type> to the store's modelFor method`);
+      }
+    })(typeof type === 'string' && type.length) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`No model was found for '${type}' and no schema handles the type`);
+      }
+    })(this.schema.hasResource({
+      type
+    })) : {};
     return getShimClass(this, type);
   }
 
@@ -3818,7 +4065,7 @@ class Store extends EmberObject {
     ```
      To create a new instance of a `Post` that has a relationship with a `User` record:
      ```js
-    let user = this.store.peekRecord('user', 1);
+    let user = this.store.peekRecord('user', '1');
     store.createRecord('post', {
       title: 'Ember is awesome!',
       user: user
@@ -3826,17 +4073,26 @@ class Store extends EmberObject {
     ```
      @method createRecord
     @public
-    @param {String} modelName
+    @param {String} type the name of the resource
     @param {Object} inputProperties a hash of properties to set on the
       newly created record.
     @return {Model} record
   */
-  createRecord(modelName, inputProperties) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+
+  createRecord(type, inputProperties) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyingStore(this, 'createRecord');
     }
-    assert(`You need to pass a model name to the store's createRecord method`, modelName);
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass a model name to the store's createRecord method`);
+      }
+    })(type) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
+      }
+    })(typeof type === 'string') : {};
 
     // This is wrapped in a `run.join` so that in test environments users do not need to manually wrap
     //   calls to `createRecord`. The run loop usage here is because we batch the joining and updating
@@ -3845,7 +4101,7 @@ class Store extends EmberObject {
     //   to remove this, we would need to move to a new `async` API.
     let record;
     this._join(() => {
-      const normalizedModelName = normalizeModelName(modelName);
+      const normalizedModelName = normalizeModelName(type);
       const properties = {
         ...inputProperties
       };
@@ -3854,25 +4110,28 @@ class Store extends EmberObject {
       // give the adapter an opportunity to generate one. Typically,
       // client-side ID generators will use something like uuid.js
       // to avoid conflicts.
-
+      let id = null;
       if (properties.id === null || properties.id === undefined) {
-        const adapter = this.adapterFor?.(modelName, true);
+        const adapter = this.adapterFor?.(normalizedModelName, true);
         if (adapter && adapter.generateIdForRecord) {
-          properties.id = adapter.generateIdForRecord(this, modelName, properties);
+          id = properties.id = coerceId(adapter.generateIdForRecord(this, normalizedModelName, properties));
         } else {
-          properties.id = null;
+          id = properties.id = null;
         }
+      } else {
+        id = properties.id = coerceId(properties.id);
       }
-
-      // Coerce ID to a string
-      properties.id = coerceId(properties.id);
       const resource = {
         type: normalizedModelName,
-        id: properties.id
+        id
       };
       if (resource.id) {
         const identifier = this.identifierCache.peekRecordIdentifier(resource);
-        assert(`The id ${String(properties.id)} has already been used with another '${normalizedModelName}' record.`, !identifier);
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`The id ${String(properties.id)} has already been used with another '${normalizedModelName}' record.`);
+          }
+        })(!identifier) : {};
       }
       const identifier = this.identifierCache.createIdentifierForNewRecord(resource);
       const cache = this.cache;
@@ -3894,15 +4153,19 @@ class Store extends EmberObject {
     ```
      @method deleteRecord
     @public
-    @param {Model} record
+    @param {unknown} record
   */
   deleteRecord(record) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyingStore(this, 'deleteRecord');
     }
     const identifier = peekRecordIdentifier(record);
     const cache = this.cache;
-    assert(`expected the record to be connected to a cache`, identifier);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`expected the record to be connected to a cache`);
+      }
+    })(identifier) : {};
     this._join(() => {
       cache.setIsDeleted(identifier, true);
       if (cache.isNew(identifier)) {
@@ -3916,7 +4179,7 @@ class Store extends EmberObject {
     This will cause the record to be destroyed and freed up for garbage collection.
      Example
      ```javascript
-    store.findRecord('post', 1).then(function(post) {
+    store.findRecord('post', '1').then(function(post) {
       store.unloadRecord(post);
     });
     ```
@@ -3925,7 +4188,7 @@ class Store extends EmberObject {
     @param {Model} record
   */
   unloadRecord(record) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyingStore(this, 'unloadRecord');
     }
     const identifier = peekRecordIdentifier(record);
@@ -3942,8 +4205,7 @@ class Store extends EmberObject {
     resolved with the record.
      **Example 1**
      ```app/routes/post.js
-    import Route from '@ember/routing/route';
-     export default class PostRoute extends Route {
+    export default class PostRoute extends Route {
       model({ post_id }) {
         return this.store.findRecord('post', post_id);
       }
@@ -3954,8 +4216,7 @@ class Store extends EmberObject {
     of `type` (modelName) and `id` as separate arguments. You may recognize this combo as
     the typical pairing from [JSON:API](https://jsonapi.org/format/#document-resource-object-identification)
      ```app/routes/post.js
-    import Route from '@ember/routing/route';
-     export default class PostRoute extends Route {
+    export default class PostRoute extends Route {
       model({ post_id: id }) {
         return this.store.findRecord({ type: 'post', id });
       }
@@ -3978,8 +4239,7 @@ class Store extends EmberObject {
     for the comment also looks like `/posts/1/comments/2` if you want to fetch the comment
     without also fetching the post you can pass in the post to the `findRecord` call:
      ```app/routes/post-comments.js
-    import Route from '@ember/routing/route';
-     export default class PostRoute extends Route {
+    export default class PostRoute extends Route {
       model({ post_id, comment_id: id }) {
         return this.store.findRecord({ type: 'comment', id, { preload: { post: post_id }} });
       }
@@ -4005,8 +4265,7 @@ class Store extends EmberObject {
      This could also be achieved by supplying the post id to the adapter via the adapterOptions
     property on the options hash.
      ```app/routes/post-comments.js
-    import Route from '@ember/routing/route';
-     export default class PostRoute extends Route {
+    export default class PostRoute extends Route {
       model({ post_id, comment_id: id }) {
         return this.store.findRecord({ type: 'comment', id, { adapterOptions: { post: post_id }} });
       }
@@ -4029,8 +4288,8 @@ class Store extends EmberObject {
     ```
      If you have access to the post model you can also pass the model itself to preload:
      ```javascript
-    let post = await store.findRecord('post', 1);
-    let comment = await store.findRecord('comment', 2, { post: myPostModel });
+    let post = await store.findRecord('post', '1');
+    let comment = await store.findRecord('comment', '2', { post: myPostModel });
     ```
      ### Reloading
      The reload behavior is configured either via the passed `options` hash or
@@ -4054,7 +4313,7 @@ class Store extends EmberObject {
     //     revision: 2
     //   }
     // ]
-    store.findRecord('post', 1, { reload: true }).then(function(post) {
+    store.findRecord('post', '1', { reload: true }).then(function(post) {
       post.revision; // 2
     });
     ```
@@ -4083,7 +4342,7 @@ class Store extends EmberObject {
         revision: 1
       }
     });
-     let blogPost = store.findRecord('post', 1).then(function(post) {
+     let blogPost = store.findRecord('post', '1').then(function(post) {
       post.revision; // 1
     });
      // later, once adapter#findRecord resolved with
@@ -4100,8 +4359,7 @@ class Store extends EmberObject {
     boolean value for `backgroundReload` in the options object for
     `findRecord`.
      ```app/routes/post/edit.js
-    import Route from '@ember/routing/route';
-     export default class PostEditRoute extends Route {
+    export default class PostEditRoute extends Route {
       model(params) {
         return this.store.findRecord('post', params.post_id, { backgroundReload: false });
       }
@@ -4110,8 +4368,7 @@ class Store extends EmberObject {
      If you pass an object on the `adapterOptions` property of the options
     argument it will be passed to your adapter via the snapshot
      ```app/routes/post/edit.js
-    import Route from '@ember/routing/route';
-     export default class PostEditRoute extends Route {
+    export default class PostEditRoute extends Route {
       model(params) {
         return this.store.findRecord('post', params.post_id, {
           adapterOptions: { subscribe: false }
@@ -4143,8 +4400,7 @@ class Store extends EmberObject {
     model, when we retrieve a specific post we can have the server also return that post's
     comments in the same request:
      ```app/routes/post.js
-    import Route from '@ember/routing/route';
-     export default class PostRoute extends Route {
+    export default class PostRoute extends Route {
       model(params) {
         return this.store.findRecord('post', params.post_id, { include: 'comments' });
       }
@@ -4172,8 +4428,7 @@ class Store extends EmberObject {
     using a dot-separated sequence of relationship names. So to request both the post's
     comments and the authors of those comments the request would look like this:
      ```app/routes/post.js
-    import Route from '@ember/routing/route';
-     export default class PostRoute extends Route {
+    export default class PostRoute extends Route {
       model(params) {
         return this.store.findRecord('post', params.post_id, { include: 'comments,comments.author' });
       }
@@ -4196,41 +4451,47 @@ class Store extends EmberObject {
      2. Then pass through the applicable fields to your `findRecord` request.
      Given a `post` model with attributes body, title, publishDate and meta, you can retrieve a filtered list of attributes.
      ```app/routes/post.js
-    import Route from '@ember/routing/route';
-    export default Route.extend({
+    export default class extends Route {
       model(params) {
         return this.store.findRecord('post', params.post_id, { adapterOptions: { fields: { post: 'body,title' } });
       }
-    });
+    }
     ```
      Moreover, you can filter attributes on related models as well. If a `post` has a `belongsTo` relationship to a user,
     just include the relationship key and attributes.
      ```app/routes/post.js
-    import Route from '@ember/routing/route';
-    export default Route.extend({
+    export default class extends Route {
       model(params) {
         return this.store.findRecord('post', params.post_id, { adapterOptions: { fields: { post: 'body,title', user: 'name,email' } });
       }
-    });
+    }
     ```
      @since 1.13.0
     @method findRecord
     @public
-    @param {String|object} modelName - either a string representing the modelName or a ResourceIdentifier object containing both the type (a string) and the id (a string) for the record or an lid (a string) of an existing record
+    @param {String|object} type - either a string representing the name of the resource or a ResourceIdentifier object containing both the type (a string) and the id (a string) for the record or an lid (a string) of an existing record
     @param {(String|Integer|Object)} id - optional object with options for the request only if the first param is a ResourceIdentifier, else the string id of the record to be retrieved
     @param {Object} [options] - if the first param is a string this will be the optional options for the request. See examples for available options.
     @return {Promise} promise
   */
 
   findRecord(resource, id, options) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyingStore(this, 'findRecord');
     }
-    assert(`You need to pass a modelName or resource identifier as the first argument to the store's findRecord method`, resource);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass a modelName or resource identifier as the first argument to the store's findRecord method`);
+      }
+    })(resource) : {};
     if (isMaybeIdentifier(resource)) {
       options = id;
     } else {
-      assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${resource}`, typeof resource === 'string');
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${resource}`);
+        }
+      })(typeof resource === 'string') : {};
       const type = normalizeModelName(resource);
       const normalizedId = ensureStringId(id);
       resource = constructResource(type, normalizedId);
@@ -4267,7 +4528,7 @@ class Store extends EmberObject {
     Get the reference for the specified record.
      Example
      ```javascript
-    let userRef = store.getReference('user', 1);
+    let userRef = store.getReference('user', '1');
      // check if the user is loaded
     let isLoaded = userRef.value() !== null;
      // get the record of the reference (null if not yet available)
@@ -4294,7 +4555,7 @@ class Store extends EmberObject {
   */
   // TODO @deprecate getReference (and references generally)
   getReference(resource, id) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyingStore(this, 'getReference');
     }
     let resourceIdentifier;
@@ -4305,7 +4566,11 @@ class Store extends EmberObject {
       const normalizedId = ensureStringId(id);
       resourceIdentifier = constructResource(type, normalizedId);
     }
-    assert('getReference expected to receive either a resource identifier or type and id as arguments', isMaybeIdentifier(resourceIdentifier));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error('getReference expected to receive either a resource identifier or type and id as arguments');
+      }
+    })(isMaybeIdentifier(resourceIdentifier)) : {};
     const identifier = this.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);
     return this._instanceCache.getReference(identifier);
   }
@@ -4319,8 +4584,8 @@ class Store extends EmberObject {
      _Note: This is a synchronous method and does not return a promise._
      **Example 1**
      ```js
-    let post = store.peekRecord('post', 1);
-     post.id; // 1
+    let post = store.peekRecord('post', '1');
+     post.id; // '1'
     ```
      `peekRecord` can be called with a single identifier argument instead of the combination
     of `type` (modelName) and `id` as separate arguments. You may recognize this combo as
@@ -4328,14 +4593,14 @@ class Store extends EmberObject {
      **Example 2**
      ```js
     let post = store.peekRecord({ type: 'post', id });
-    post.id; // 1
+    post.id; // '1'
     ```
      If you have previously received an lid from an Identifier for this record, you can lookup the record again using
     just the lid.
      **Example 3**
      ```js
     let post = store.peekRecord({ lid });
-    post.id; // 1
+    post.id; // '1'
     ```
       @since 1.13.0
     @method peekRecord
@@ -4353,11 +4618,19 @@ class Store extends EmberObject {
       // this is basically an "are we not empty" query.
       return isLoaded ? this._instanceCache.getRecord(stableIdentifier) : null;
     }
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyingStore(this, 'peekRecord');
     }
-    assert(`You need to pass a model name to the store's peekRecord method`, identifier);
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${String(identifier)}`, typeof identifier === 'string');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass a model name to the store's peekRecord method`);
+      }
+    })(identifier) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${String(identifier)}`);
+      }
+    })(typeof identifier === 'string') : {};
     const type = normalizeModelName(identifier);
     const normalizedId = ensureStringId(id);
     const resource = {
@@ -4388,7 +4661,7 @@ class Store extends EmberObject {
      ---
      If you do something like this:
      ```javascript
-    store.query('person', { ids: [1, 2, 3] });
+    store.query('person', { ids: ['1', '2', '3'] });
     ```
      The request made to the server will look something like this:
      ```
@@ -4401,24 +4674,37 @@ class Store extends EmberObject {
      @since 1.13.0
     @method query
     @public
-    @param {String} modelName
-    @param {any} query an opaque query to be used by the adapter
+    @param {String} type the name of the resource
+    @param {object} query a query to be used by the adapter
     @param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter.query
     @return {Promise} promise
   */
-  query(modelName, query, options) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+
+  query(type, query, options = {}) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyingStore(this, 'query');
     }
-    assert(`You need to pass a model name to the store's query method`, modelName);
-    assert(`You need to pass a query hash to the store's query method`, query);
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass a model name to the store's query method`);
+      }
+    })(type) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass a query hash to the store's query method`);
+      }
+    })(query) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
+      }
+    })(typeof type === 'string') : {};
     const promise = this.request({
       op: 'query',
       data: {
-        type: normalizeModelName(modelName),
+        type: normalizeModelName(type),
         query,
-        options: options || {}
+        options: options
       },
       cacheOptions: {
         [SkipCache]: true
@@ -4503,22 +4789,35 @@ class Store extends EmberObject {
      @since 1.13.0
     @method queryRecord
     @public
-    @param {String} modelName
-    @param {any} query an opaque query to be used by the adapter
-    @param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter.queryRecord
+    @param {string} type
+    @param {object} query an opaque query to be used by the adapter
+    @param {object} options optional, may include `adapterOptions` hash which will be passed to adapter.queryRecord
     @return {Promise} promise which resolves with the found record or `null`
   */
-  queryRecord(modelName, query, options) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+
+  queryRecord(type, query, options) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyingStore(this, 'queryRecord');
     }
-    assert(`You need to pass a model name to the store's queryRecord method`, modelName);
-    assert(`You need to pass a query hash to the store's queryRecord method`, query);
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass a model name to the store's queryRecord method`);
+      }
+    })(type) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass a query hash to the store's queryRecord method`);
+      }
+    })(query) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
+      }
+    })(typeof type === 'string') : {};
     const promise = this.request({
       op: 'queryRecord',
       data: {
-        type: normalizeModelName(modelName),
+        type: normalizeModelName(type),
         query,
         options: options || {}
       },
@@ -4535,8 +4834,7 @@ class Store extends EmberObject {
     this type present in the store, even if the adapter only returns a subset
     of them.
      ```app/routes/authors.js
-    import Route from '@ember/routing/route';
-     export default class AuthorsRoute extends Route {
+    export default class AuthorsRoute extends Route {
       model(params) {
         return this.store.findAll('author');
       }
@@ -4609,8 +4907,7 @@ class Store extends EmberObject {
     boolean value for `backgroundReload` in the options object for
     `findAll`.
      ```app/routes/post/edit.js
-    import Route from '@ember/routing/route';
-     export default class PostEditRoute extends Route {
+    export default class PostEditRoute extends Route {
       model() {
         return this.store.findAll('post', { backgroundReload: false });
       }
@@ -4619,8 +4916,7 @@ class Store extends EmberObject {
      If you pass an object on the `adapterOptions` property of the options
     argument it will be passed to you adapter via the `snapshotRecordArray`
      ```app/routes/posts.js
-    import Route from '@ember/routing/route';
-     export default class PostsRoute extends Route {
+    export default class PostsRoute extends Route {
       model(params) {
         return this.store.findAll('post', {
           adapterOptions: { subscribe: false }
@@ -4653,8 +4949,7 @@ class Store extends EmberObject {
     model, when we retrieve all of the post records we can have the server also return
     all of the posts' comments in the same request:
      ```app/routes/posts.js
-    import Route from '@ember/routing/route';
-     export default class PostsRoute extends Route {
+    export default class PostsRoute extends Route {
       model() {
         return this.store.findAll('post', { include: 'comments' });
       }
@@ -4665,8 +4960,7 @@ class Store extends EmberObject {
     using a dot-separated sequence of relationship names. So to request both the posts'
     comments and the authors of those comments the request would look like this:
      ```app/routes/posts.js
-    import Route from '@ember/routing/route';
-     export default class PostsRoute extends Route {
+    export default class PostsRoute extends Route {
       model() {
         return this.store.findAll('post', { include: 'comments,comments.author' });
       }
@@ -4676,20 +4970,29 @@ class Store extends EmberObject {
      @since 1.13.0
     @method findAll
     @public
-    @param {String} modelName
-    @param {Object} options
+    @param {string} type the name of the resource
+    @param {object} options
     @return {Promise} promise
   */
-  findAll(modelName, options = {}) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+
+  findAll(type, options = {}) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyingStore(this, 'findAll');
     }
-    assert(`You need to pass a model name to the store's findAll method`, modelName);
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass a model name to the store's findAll method`);
+      }
+    })(type) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
+      }
+    })(typeof type === 'string') : {};
     const promise = this.request({
       op: 'findAll',
       data: {
-        type: normalizeModelName(modelName),
+        type: normalizeModelName(type),
         options: options || {}
       },
       cacheOptions: {
@@ -4716,17 +5019,25 @@ class Store extends EmberObject {
      @since 1.13.0
     @method peekAll
     @public
-    @param {String} modelName
+    @param {string} type the name of the resource
     @return {RecordArray}
   */
-  peekAll(modelName) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+
+  peekAll(type) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyingStore(this, 'peekAll');
     }
-    assert(`You need to pass a model name to the store's peekAll method`, modelName);
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
-    const type = normalizeModelName(modelName);
-    return this.recordArrayManager.liveArrayFor(type);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You need to pass a model name to the store's peekAll method`);
+      }
+    })(type) : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
+      }
+    })(typeof type === 'string') : {};
+    return this.recordArrayManager.liveArrayFor(normalizeModelName(type));
   }
 
   /**
@@ -4738,16 +5049,21 @@ class Store extends EmberObject {
     store.unloadAll('post');
     ```
      @method unloadAll
+    @param {string} type the name of the resource
     @public
-    @param {String} modelName
   */
-  unloadAll(modelName) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+
+  unloadAll(type) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyedStoreOnly(this, 'unloadAll');
     }
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${String(modelName)}`, !modelName || typeof modelName === 'string');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${String(type)}`);
+      }
+    })(!type || typeof type === 'string') : {};
     this._join(() => {
-      if (modelName === undefined) {
+      if (type === undefined) {
         // destroy the graph before unloadAll
         // since then we avoid churning relationships
         // during unload
@@ -4755,8 +5071,7 @@ class Store extends EmberObject {
         this.recordArrayManager.clear();
         this._instanceCache.clear();
       } else {
-        const normalizedModelName = normalizeModelName(modelName);
-        this._instanceCache.clear(normalizedModelName);
+        this._instanceCache.clear(normalizeModelName(type));
       }
     });
   }
@@ -4893,7 +5208,7 @@ class Store extends EmberObject {
   */
 
   push(data) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyingStore(this, 'push');
     }
     const pushed = this._push(data, false);
@@ -4915,10 +5230,10 @@ class Store extends EmberObject {
     @return {StableRecordIdentifier|Array<StableRecordIdentifier>|null} identifiers for the primary records that had data loaded
   */
   _push(jsonApiDoc, asyncFlush) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyingStore(this, '_push');
     }
-    if (macroCondition(getOwnConfig().debug.LOG_PAYLOADS)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.debug.LOG_PAYLOADS)) {
       try {
         const data = JSON.parse(JSON.stringify(jsonApiDoc));
         // eslint-disable-next-line no-console
@@ -4944,17 +5259,23 @@ class Store extends EmberObject {
   /**
    * Trigger a save for a Record.
    *
+   * Returns a promise resolving with the same record when the save is complete.
+   *
    * @method saveRecord
    * @public
-   * @param {RecordInstance} record
+   * @param {unknown} record
    * @param options
-   * @return {Promise<RecordInstance>}
+   * @return {Promise<record>}
    */
   saveRecord(record, options = {}) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyingStore(this, 'saveRecord');
     }
-    assert(`Unable to initate save for a record in a disconnected state`, storeFor(record));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Unable to initiate save for a record in a disconnected state`);
+      }
+    })(storeFor(record)) : {};
     const identifier = recordIdentifierFor(record);
     const cache = this.cache;
     if (!identifier) {
@@ -4962,8 +5283,11 @@ class Store extends EmberObject {
       // but just in case we reject here to prevent bad things.
       return Promise.reject(new Error(`Record Is Disconnected`));
     }
-    // TODO we used to check if the record was destroyed here
-    assert(`Cannot initiate a save request for an unloaded record: ${identifier.lid}`, this._instanceCache.recordIsLoaded(identifier));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Cannot initiate a save request for an unloaded record: ${identifier.lid}`);
+      }
+    })(this._instanceCache.recordIsLoaded(identifier)) : {};
     if (resourceIsFullyDeleted(this._instanceCache, identifier)) {
       return Promise.resolve(record);
     }
@@ -4987,11 +5311,6 @@ class Store extends EmberObject {
         [SkipCache]: true
       }
     };
-
-    // we lie here on the type because legacy doesn't have enough context
-    cache.willCommit(identifier, {
-      request
-    });
     return this.request(request).then(document => document.content);
   }
 
@@ -5021,14 +5340,12 @@ class Store extends EmberObject {
     } = this._instanceCache;
     if (!cache) {
       cache = this._instanceCache.cache = this.createCache(this._instanceCache._storeWrapper);
-      if (macroCondition(getOwnConfig().env.DEBUG)) {
+      if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
         cache = new CacheManager(cache);
       }
     }
     return cache;
   }
-
-  // @ts-expect-error
   destroy() {
     if (this.isDestroyed) {
       // @ember/test-helpers will call destroy multiple times
@@ -5047,16 +5364,67 @@ class Store extends EmberObject {
     return new this(args);
   }
 }
+if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA_SERVICE)) {
+  Store.prototype.getSchemaDefinitionService = function () {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You must registerSchemaDefinitionService with the store to use custom model classes`);
+      }
+    })(this._schema) : {};
+    deprecate(`Use \`store.schema\` instead of \`store.getSchemaDefinitionService()\``, false, {
+      id: 'ember-data:schema-service-updates',
+      until: '5.0',
+      for: 'ember-data',
+      since: {
+        available: '5.4',
+        enabled: '5.4'
+      }
+    });
+    return this._schema;
+  };
+  Store.prototype.registerSchemaDefinitionService = function (schema) {
+    deprecate(`Use \`store.createSchemaService\` instead of \`store.registerSchemaDefinitionService()\``, false, {
+      id: 'ember-data:schema-service-updates',
+      until: '5.0',
+      for: 'ember-data',
+      since: {
+        available: '5.4',
+        enabled: '5.4'
+      }
+    });
+    this._schema = schema;
+  };
+  Store.prototype.registerSchema = function (schema) {
+    deprecate(`Use \`store.createSchemaService\` instead of \`store.registerSchema()\``, false, {
+      id: 'ember-data:schema-service-updates',
+      until: '5.0',
+      for: 'ember-data',
+      since: {
+        available: '5.4',
+        enabled: '5.4'
+      }
+    });
+    this._schema = schema;
+  };
+}
 let assertDestroyingStore;
 let assertDestroyedStoreOnly;
-if (macroCondition(getOwnConfig().env.DEBUG)) {
+if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
   // eslint-disable-next-line @typescript-eslint/no-shadow
   assertDestroyingStore = function assertDestroyingStore(store, method) {
-    assert(`Attempted to call store.${method}(), but the store instance has already been destroyed.`, !(store.isDestroying || store.isDestroyed));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Attempted to call store.${method}(), but the store instance has already been destroyed.`);
+      }
+    })(!(store.isDestroying || store.isDestroyed)) : {};
   };
   // eslint-disable-next-line @typescript-eslint/no-shadow
   assertDestroyedStoreOnly = function assertDestroyedStoreOnly(store, method) {
-    assert(`Attempted to call store.${method}(), but the store instance has already been destroyed.`, !store.isDestroyed);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Attempted to call store.${method}(), but the store instance has already been destroyed.`);
+      }
+    })(!store.isDestroyed) : {};
   };
 }
 function isMaybeIdentifier(maybeIdentifier) {
@@ -5066,33 +5434,38 @@ function normalizeProperties(store, identifier, properties) {
   // assert here
   if (properties !== undefined) {
     if ('id' in properties) {
-      assert(`expected id to be a string or null`, properties.id !== undefined);
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`expected id to be a string or null`);
+        }
+      })(properties.id !== undefined) : {};
     }
-    assert(`You passed '${typeof properties}' as properties for record creation instead of an object.`, typeof properties === 'object' && properties !== null);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You passed '${typeof properties}' as properties for record creation instead of an object.`);
+      }
+    })(typeof properties === 'object' && properties !== null) : {};
     const {
       type
     } = identifier;
 
     // convert relationship Records to RecordDatas before passing to RecordData
-    const defs = store.getSchemaDefinitionService().relationshipsDefinitionFor({
+    const defs = store.schema.fields({
       type
     });
-    if (defs !== null) {
+    if (defs.size) {
       const keys = Object.keys(properties);
-      let relationshipValue;
       for (let i = 0; i < keys.length; i++) {
         const prop = keys[i];
-        const def = defs[prop];
-        if (def !== undefined) {
-          if (def.kind === 'hasMany') {
-            if (macroCondition(getOwnConfig().env.DEBUG)) {
-              assertRecordsPassedToHasMany(properties[prop]);
-            }
-            relationshipValue = extractIdentifiersFromRecords(properties[prop]);
-          } else {
-            relationshipValue = extractIdentifierFromRecord(properties[prop]);
+        const field = defs.get(prop);
+        if (!field) continue;
+        if (field.kind === 'hasMany') {
+          if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+            assertRecordsPassedToHasMany(properties[prop]);
           }
-          properties[prop] = relationshipValue;
+          properties[prop] = extractIdentifiersFromRecords(properties[prop]);
+        } else if (field.kind === 'belongsTo') {
+          properties[prop] = extractIdentifierFromRecord(properties[prop]);
         }
       }
     }
@@ -5100,8 +5473,16 @@ function normalizeProperties(store, identifier, properties) {
   return properties;
 }
 function assertRecordsPassedToHasMany(records) {
-  assert(`You must pass an array of records to set a hasMany relationship`, Array.isArray(records));
-  assert(`All elements of a hasMany relationship must be instances of Model, you passed ${records.map(r => `${typeof r}`).join(', ')}`, function () {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`You must pass an array of records to set a hasMany relationship`);
+    }
+  })(Array.isArray(records)) : {};
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`All elements of a hasMany relationship must be instances of Model, you passed ${records.map(r => `${typeof r}`).join(', ')}`);
+    }
+  })(function () {
     return records.every(record => {
       try {
         recordIdentifierFor(record);
@@ -5110,7 +5491,7 @@ function assertRecordsPassedToHasMany(records) {
         return false;
       }
     });
-  }());
+  }()) : {};
 }
 function extractIdentifiersFromRecords(records) {
   return records.map(record => extractIdentifierFromRecord(record));
@@ -5122,6 +5503,10 @@ function extractIdentifierFromRecord(recordOrPromiseRecord) {
   const extract = recordIdentifierFor;
   return extract(recordOrPromiseRecord);
 }
+
+/**
+ * @module @ember-data/store
+ */
 function urlFromLink(link) {
   if (typeof link === 'string') return link;
   return link.href;
@@ -5139,69 +5524,79 @@ function urlFromLink(link) {
  * @public
  * @class Document
  */
-var _store = /*#__PURE__*/_classPrivateFieldKey("store");
-var _request = /*#__PURE__*/_classPrivateFieldKey("request");
 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) {
-    Object.defineProperty(this, _request, {
-      value: _request2
-    });
-    /**
-     * The links object for this document, if any
-     *
-     * e.g.
-     *
-     * ```
-     * {
-     *   self: '/articles?page[number]=3',
-     * }
-     * ```
-     *
-     * @property links
-     * @type {object|undefined} - a links object
-     * @public
-     */
-    /**
-     * The primary data for this document, if any.
-     *
-     * If this document has no primary data (e.g. because it is an error document)
-     * this property will be `undefined`.
-     *
-     * For collections this will be an array of record instances,
-     * for single resource requests it will be a single record instance or null.
-     *
-     * @property data
-     * @public
-     * @type {object|Array<object>|null|undefined} - a data object
-     */
-    /**
-     * The errors returned by the API for this request, if any
-     *
-     * @property errors
-     * @public
-     * @type {object|undefined} - an errors object
-     */
-    /**
-     * The meta object for this document, if any
-     *
-     * @property meta
-     * @public
-     * @type {object|undefined} - a meta object
-     */
-    /**
-     * The identifier associated with this document, if any
-     *
-     * @property identifier
-     * @public
-     * @type {StableDocumentIdentifier|null}
-     */
-    Object.defineProperty(this, _store, {
-      writable: true,
-      value: void 0
-    });
-    _classPrivateFieldBase(this, _store)[_store] = store;
+    this.#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,
@@ -5213,10 +5608,14 @@ class Document {
    * @return Promise<Document>
    */
   fetch(options = {}) {
-    assert(`No self or related link`, this.links?.related || this.links?.self);
+    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 _classPrivateFieldBase(this, _request)[_request](this.links.related ? 'related' : 'self', options);
+    return this.#request(this.links.related ? 'related' : 'self', options);
   }
 
   /**
@@ -5230,7 +5629,7 @@ class Document {
    * @return Promise<Document | null>
    */
   next(options = {}) {
-    return _classPrivateFieldBase(this, _request)[_request]('next', options);
+    return this.#request('next', options);
   }
 
   /**
@@ -5244,7 +5643,7 @@ class Document {
    * @return Promise<Document | null>
    */
   prev(options = {}) {
-    return _classPrivateFieldBase(this, _request)[_request]('prev', options);
+    return this.#request('prev', options);
   }
 
   /**
@@ -5258,7 +5657,7 @@ class Document {
    * @return Promise<Document | null>
    */
   first(options = {}) {
-    return _classPrivateFieldBase(this, _request)[_request]('first', options);
+    return this.#request('first', options);
   }
 
   /**
@@ -5272,7 +5671,7 @@ class Document {
    * @return Promise<Document | null>
    */
   last(options = {}) {
-    return _classPrivateFieldBase(this, _request)[_request]('last', options);
+    return this.#request('last', options);
   }
 
   /**
@@ -5306,17 +5705,6 @@ class Document {
     return data;
   }
 }
-async function _request2(link, options) {
-  const href = this.links?.[link];
-  if (!href) {
-    return null;
-  }
-  options.method = options.method || 'GET';
-  const response = await _classPrivateFieldBase(this, _store)[_store].request(Object.assign(options, {
-    url: urlFromLink(href)
-  }));
-  return response.content;
-}
 defineSignal(Document.prototype, 'data');
 defineSignal(Document.prototype, 'links');
 defineSignal(Document.prototype, 'errors');
@@ -5337,10 +5725,9 @@ defineSignal(Document.prototype, 'meta');
  * Implementing this service allows you to programatically define
  * when a request should be considered expired.
  *
- * @class <Interface> LifetimesService
+ * @class <Interface> CachePolicy
  * @public
  */
-
 const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);
 function isErrorDocument(document) {
   return 'errors' in document;
@@ -5349,6 +5736,14 @@ function maybeUpdateUiObjects(store, request, options, document, isFromCache) {
   const {
     identifier
   } = options;
+  if (!document) {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`The CacheHandler expected response content but none was found`);
+      }
+    })(!options.shouldHydrate) : {};
+    return document;
+  }
   if (isErrorDocument(document)) {
     if (!identifier && !options.shouldHydrate) {
       return document;
@@ -5446,7 +5841,7 @@ function calcShouldBackgroundFetch(store, request, willFetch, identifier) {
   const {
     cacheOptions
   } = request;
-  return !willFetch && (cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier, store) : false));
+  return cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier, store) : false);
 }
 function isMutation(request) {
   return Boolean(request.op && MUTATION_OPS.has(request.op));
@@ -5461,8 +5856,14 @@ function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBa
     isMut = true;
     // TODO should we handle multiple records in request.records by iteratively calling willCommit for each
     const record = context.request.data?.record || context.request.records?.[0];
-    assert(`Expected to receive a list of records included in the ${context.request.op} request`, record);
-    store.cache.willCommit(record, context);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected to receive a list of records included in the ${context.request.op} request`);
+      }
+    })(record || !shouldHydrate) : {};
+    if (record) {
+      store.cache.willCommit(record, context);
+    }
   }
   if (store.lifetimes?.willRequest) {
     store.lifetimes.willRequest(context.request, identifier, store);
@@ -5474,7 +5875,15 @@ function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBa
     store._join(() => {
       if (isMutation(context.request)) {
         const record = context.request.data?.record || context.request.records?.[0];
-        response = store.cache.didCommit(record, document);
+        if (record) {
+          response = store.cache.didCommit(record, document);
+
+          // a mutation combined with a 204 has no cache impact when no known records were involved
+          // a createRecord with a 201 with an empty response and no known records should similarly
+          // have no cache impact
+        } else if (isCacheAffecting(document)) {
+          response = store.cache.put(document);
+        }
       } else {
         response = store.cache.put(document);
       }
@@ -5536,7 +5945,11 @@ function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBa
   if (!isMut) {
     return promise;
   }
-  assert(`Expected a mutation`, isMutation(context.request));
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected a mutation`);
+    }
+  })(isMutation(context.request)) : {};
 
   // for mutations we need to enqueue the promise with the requestStateService
   // TODO should we enque a request per record in records?
@@ -5549,12 +5962,62 @@ function fetchContentAndHydrate(next, context, identifier, shouldFetch, shouldBa
     }]
   });
 }
+function isAggregateError(error) {
+  return error instanceof AggregateError || error.name === 'AggregateError' && Array.isArray(error.errors);
+}
+// TODO @runspired, consider if we should deep freeze errors (potentially only in debug) vs cloning them
 function cloneError(error) {
-  const cloned = new Error(error.message);
+  const isAggregate = isAggregateError(error);
+  const cloned = isAggregate ? new AggregateError(structuredClone(error.errors), error.message) : new Error(error.message);
   cloned.stack = error.stack;
   cloned.error = error.error;
+
+  // copy over enumerable properties
+  Object.assign(cloned, error);
   return cloned;
 }
+
+/**
+ * A CacheHandler that adds support for using an EmberData Cache with a RequestManager.
+ *
+ * This handler will only run when a request has supplied a `store` instance. Requests
+ * issued by the store via `store.request()` will automatically have the `store` instance
+ * attached to the request.
+ *
+ * ```ts
+ * requestManager.request({
+ *   store: store,
+ *   url: '/api/posts',
+ *   method: 'GET'
+ * });
+ * ```
+ *
+ * When this handler elects to handle a request, it will return the raw `StructuredDocument`
+ * unless the request has `[EnableHydration]` set to `true`. In this case, the handler will
+ * return a `Document` instance that will automatically update the UI when the cache is updated
+ * in the future and will hydrate any identifiers in the StructuredDocument into Record instances.
+ *
+ * When issuing a request via the store, [EnableHydration] is automatically set to `true`. This
+ * means that if desired you can issue requests that utilize the cache without needing to also
+ * utilize Record instances if desired.
+ *
+ * Said differently, you could elect to issue all requests via a RequestManager, without ever using
+ * the store directly, by setting [EnableHydration] to `true` and providing a store instance. Not
+ * necessarily the most useful thing, but the decoupled nature of the RequestManager and incremental-feature
+ * approach of EmberData allows for this flexibility.
+ *
+ * ```ts
+ * import { EnableHydration } from '@warp-drive/core-types/request';
+ *
+ * requestManager.request({
+ *   store: store,
+ *   url: '/api/posts',
+ *   method: 'GET',
+ *   [EnableHydration]: true
+ * });
+ *
+ * @typedoc
+ */
 const CacheHandler = {
   request(context, next) {
     // if we have no cache or no cache-key skip cache handling
@@ -5577,7 +6040,13 @@ const CacheHandler = {
       const promise = fetchContentAndHydrate(next, context, identifier, false, true);
       store.requestManager._pending.set(context.id, promise);
     }
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected a peeked request to be present`);
+      }
+    })(peeked) : {};
     const shouldHydrate = context.request[EnableHydration] || false;
+    context.setResponse(peeked.response);
     if ('error' in peeked) {
       const content = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
         shouldHydrate,
@@ -5587,10 +6056,11 @@ const CacheHandler = {
       newError.content = content;
       throw newError;
     }
-    return Promise.resolve(shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
+    const result = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
       shouldHydrate,
       identifier
-    }, peeked.content, true) : peeked.content);
+    }, peeked.content, true) : peeked.content;
+    return result;
   }
 };
 function copyDocumentProperties(target, source) {
@@ -5604,4 +6074,17 @@ function copyDocumentProperties(target, source) {
     target.errors = source.errors;
   }
 }
-export { ARRAY_SIGNAL as A, CacheHandler as C, IdentifierArray as I, MUTATE as M, RecordArrayManager as R, Store as S, _clearCaches as _, setIdentifierGenerationMethod as a, setIdentifierUpdateMethod as b, setIdentifierForgetMethod as c, setIdentifierResetMethod as d, coerceId as e, Collection as f, SOURCE as g, fastPush as h, isStableIdentifier as i, removeRecordDataFor as j, setRecordIdentifier as k, StoreMap as l, setCacheFor as m, notifyArray as n, normalizeModelName as o, peekCache as p, recordIdentifierFor as r, storeFor as s };
+function isCacheAffecting(document) {
+  if (!isMutation(document.request)) {
+    return true;
+  }
+  // a mutation combined with a 204 has no cache impact when no known records were involved
+  // a createRecord with a 201 with an empty response and no known records should similarly
+  // have no cache impact
+
+  if (document.request.op === 'createRecord' && document.response?.status === 201) {
+    return document.content ? Object.keys(document.content).length > 0 : false;
+  }
+  return document.response?.status !== 204;
+}
+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 };