@ember-data/model 5.4.0-alpha.64 → 5.4.0-alpha.70

package/{addon/model-DJ9C4aZ-.js → dist/model-CsbDNxap.js}

@@ -1,18 +1,51 @@
-import { assert, deprecate } from '@ember/debug';
+import { deprecate } from '@ember/debug';
+import { dasherize } from '@ember/string';
+import { macroCondition, getGlobalConfig, dependencySatisfies, importSync } from '@embroider/macros';
 import EmberObject, { computed, get } from '@ember/object';
 import { recordIdentifierFor as recordIdentifierFor$1, storeFor as storeFor$1 } from '@ember-data/store';
-import { RecordArray, MUTATE, SOURCE, recordIdentifierFor, ARRAY_SIGNAL, notifyArray, isStableIdentifier, storeFor, peekCache, fastPush, coerceId } from '@ember-data/store/-private';
+import { LiveArray, MUTATE, SOURCE, recordIdentifierFor, ARRAY_SIGNAL, notifyArray, isStableIdentifier, storeFor, peekCache, fastPush, coerceId } from '@ember-data/store/-private';
 import { cached, compat } from '@ember-data/tracking';
-import { addToTransaction, defineSignal, getSignal, subscribe, peekSignal } from '@ember-data/tracking/-private';
+import { addToTransaction, defineSignal, peekSignal, getSignal, subscribe } from '@ember-data/tracking/-private';
 import { RecordStore } from '@warp-drive/core-types/symbols';
 import { A } from '@ember/array';
 import ArrayProxy from '@ember/array/proxy';
 import { mapBy, not } from '@ember/object/computed';
-import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
 import { upgradeStore } from '@ember-data/legacy-compat/-private';
+import { getOrSetGlobal } from '@warp-drive/core-types/-private';
 import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
 import ObjectProxy from '@ember/object/proxy';
 import { cacheFor } from '@ember/object/internals';
+function isElementDescriptor(args) {
+  const [maybeTarget, maybeKey, maybeDesc] = args;
+  return (
+    // Ensure we have the right number of args
+    args.length === 3 && (
+    // Make sure the target is a class or object (prototype)
+    typeof maybeTarget === 'function' || typeof maybeTarget === 'object' && maybeTarget !== null) &&
+    // Make sure the key is a string
+    typeof maybeKey === 'string' && (
+    // Make sure the descriptor is the right shape
+    typeof maybeDesc === 'object' && maybeDesc !== null && 'enumerable' in maybeDesc && 'configurable' in maybeDesc ||
+    // TS compatibility
+    maybeDesc === undefined)
+  );
+}
+function normalizeModelName(type) {
+  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',
+      until: '6.0',
+      for: 'ember-data',
+      since: {
+        available: '5.3',
+        enabled: '5.3'
+      }
+    });
+    return result;
+  }
+  return type;
+}
 
 /**
   @module @ember-data/store
@@ -60,7 +93,7 @@ import { cacheFor } from '@ember/object/internals';
   @class ManyArray
   @public
 */
-class RelatedCollection extends RecordArray {
+class RelatedCollection extends LiveArray {
   /**
     The loading state of this array
      @property {Boolean} isLoaded
@@ -110,8 +143,6 @@ class RelatedCollection extends RecordArray {
      @public
      */
 
-  // @ts-expect-error
-
   constructor(options) {
     super(options);
     this.isLoaded = options.isLoaded || false;
@@ -143,7 +174,7 @@ class RelatedCollection extends RecordArray {
         {
           const newValues = extractIdentifiersFromRecords(args);
           assertNoDuplicates(this, target, currentState => currentState.push(...newValues), `Cannot push duplicates to a hasMany's state.`);
-          if (macroCondition(getOwnConfig().deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
+          if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
             // dedupe
             const seen = new Set(target);
             const unique = new Set();
@@ -187,7 +218,7 @@ class RelatedCollection extends RecordArray {
         {
           const newValues = extractIdentifiersFromRecords(args);
           assertNoDuplicates(this, target, currentState => currentState.unshift(...newValues), `Cannot unshift duplicates to a hasMany's state.`);
-          if (macroCondition(getOwnConfig().deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
+          if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
             // dedupe
             const seen = new Set(target);
             const unique = new Set();
@@ -244,7 +275,7 @@ class RelatedCollection extends RecordArray {
           if (start === 0 && deleteCount === this[SOURCE].length) {
             const newValues = extractIdentifiersFromRecords(adds);
             assertNoDuplicates(this, target, currentState => currentState.splice(start, deleteCount, ...newValues), `Cannot replace a hasMany's state with a new state that contains duplicates.`);
-            if (macroCondition(getOwnConfig().deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
+            if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
               // dedupe
               const current = new Set(adds);
               const unique = Array.from(current);
@@ -261,7 +292,7 @@ class RelatedCollection extends RecordArray {
           }
           const newValues = extractIdentifiersFromRecords(adds);
           assertNoDuplicates(this, target, currentState => currentState.splice(start, deleteCount, ...newValues), `Cannot splice a hasMany's state with a new state that contains duplicates.`);
-          if (macroCondition(getOwnConfig().deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
+          if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
             // dedupe
             const currentState = target.slice();
             currentState.splice(start, deleteCount);
@@ -308,13 +339,16 @@ class RelatedCollection extends RecordArray {
           return result;
         }
       default:
-        assert(`unable to convert ${prop} into a transaction that updates the cache state for this record array`);
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`unable to convert ${prop} into a transaction that updates the cache state for this record array`);
+          }
+        })() : {};
     }
   }
   notify() {
     const signal = this[ARRAY_SIGNAL];
     signal.shouldReset = true;
-    // @ts-expect-error
     notifyArray(this);
   }
 
@@ -367,7 +401,11 @@ class RelatedCollection extends RecordArray {
     const {
       store
     } = this;
-    assert(`Expected modelName to be set`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected modelName to be set`);
+      }
+    })(this.modelName) : {};
     const record = store.createRecord(this.modelName, hash);
     this.push(record);
     return record;
@@ -384,14 +422,18 @@ RelatedCollection.prototype._inverseIsAsync = false;
 RelatedCollection.prototype.key = '';
 RelatedCollection.prototype.DEPRECATED_CLASS_NAME = 'ManyArray';
 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 extractIdentifiersFromRecords(records) {
   return records.map(extractIdentifierFromRecord$1);
@@ -405,7 +447,7 @@ function assertNoDuplicates(collection, target, callback, reason) {
   callback(state);
   if (state.length !== new Set(state).size) {
     const duplicates = state.filter((currentValue, currentIndex) => state.indexOf(currentValue) !== currentIndex);
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
       deprecate(`${reason} This behavior is deprecated. Found duplicates for the following records within the new state provided to \`<${collection.identifier.type}:${collection.identifier.id || collection.identifier.lid}>.${collection.key}\`\n\t- ${Array.from(new Set(duplicates)).map(r => isStableIdentifier(r) ? r.lid : recordIdentifierFor(r).lid).sort((a, b) => a.localeCompare(b)).join('\n\t- ')}`, false, {
         id: 'ember-data:deprecate-many-array-duplicates',
         for: 'ember-data',
@@ -464,34 +506,129 @@ function mutate(collection, mutation, _SIGNAL) {
   collection._manager.mutate(mutation);
   addToTransaction(_SIGNAL);
 }
-function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
-  var desc = {};
-  Object.keys(descriptor).forEach(function (key) {
-    desc[key] = descriptor[key];
+const PromiseObject = ObjectProxy.extend(PromiseProxyMixin);
+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;
 }
-const PromiseObject = ObjectProxy.extend(PromiseProxyMixin);
-var _dec$1, _class$6;
+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);
+}
 const LegacyPromiseProxy = Symbol.for('LegacyPromiseProxy');
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
+// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-extraneous-class
 
 const Extended = PromiseObject;
 
@@ -508,11 +645,7 @@ const Extended = PromiseObject;
   @extends PromiseObject
   @private
 */
-let PromiseBelongsTo = (_dec$1 = computed(), (_class$6 = class PromiseBelongsTo extends Extended {
-  constructor(...args) {
-    super(...args);
-    this[LegacyPromiseProxy] = true;
-  }
+class PromiseBelongsTo extends Extended {
   get id() {
     const {
       key,
@@ -525,15 +658,29 @@ let PromiseBelongsTo = (_dec$1 = computed(), (_class$6 = class PromiseBelongsTo
   // we don't proxy meta because we would need to proxy it to the relationship state container
   //  however, meta on relationships does not trigger change notifications.
   //  if you need relationship meta, you should do `record.belongsTo(relationshipName).meta()`
+  static {
+    decorateMethodV2(this.prototype, "id", [cached]);
+  }
   get meta() {
     // eslint-disable-next-line no-constant-condition
     {
-      assert('You attempted to access meta on the promise for the async belongsTo relationship ' + `${this._belongsToState.modelName}:${this._belongsToState.key}'.` + '\nUse `record.belongsTo(relationshipName).meta()` instead.', false);
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        {
+          throw new Error('You attempted to access meta on the promise for the async belongsTo relationship ' + `${this._belongsToState.modelName}:${this._belongsToState.key}'.` + '\nUse `record.belongsTo(relationshipName).meta()` instead.');
+        }
+      })() : {};
     }
     return;
   }
+  static {
+    decorateMethodV2(this.prototype, "meta", [computed()]);
+  }
   async reload(options) {
-    assert('You are trying to reload an async belongsTo before it has been created', this.content !== undefined);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error('You are trying to reload an async belongsTo before it has been created');
+      }
+    })(this.content !== undefined) : {};
     const {
       key,
       legacySupport
@@ -541,8 +688,9 @@ let PromiseBelongsTo = (_dec$1 = computed(), (_class$6 = class PromiseBelongsTo
     await legacySupport.reloadBelongsTo(key, options);
     return this;
   }
-}, (_applyDecoratedDescriptor(_class$6.prototype, "id", [cached], Object.getOwnPropertyDescriptor(_class$6.prototype, "id"), _class$6.prototype), _applyDecoratedDescriptor(_class$6.prototype, "meta", [_dec$1], Object.getOwnPropertyDescriptor(_class$6.prototype, "meta"), _class$6.prototype)), _class$6));
-var _class$5;
+  [LegacyPromiseProxy] = true;
+}
+
 /**
  @module @ember-data/model
  */
@@ -562,9 +710,8 @@ var _class$5;
   @class PromiseManyArray
   @public
 */
-let PromiseManyArray = (_class$5 = class PromiseManyArray {
+class PromiseManyArray {
   constructor(promise, content) {
-    this[LegacyPromiseProxy] = true;
     this._update(promise, content);
     this.isDestroyed = false;
   }
@@ -577,7 +724,7 @@ let PromiseManyArray = (_class$5 = class PromiseManyArray {
   get length() {
     // shouldn't be needed, but ends up being needed
     // for computed chains even in 4.x
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_COMPUTED_CHAINS)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_COMPUTED_CHAINS)) {
       this['[]'];
     }
     return this.content ? this.content.length : 0;
@@ -593,6 +740,9 @@ let PromiseManyArray = (_class$5 = class PromiseManyArray {
    * @return
    * @private
    */
+  static {
+    decorateMethodV2(this.prototype, "length", [compat]);
+  }
   forEach(cb) {
     if (this.content && this.length) {
       this.content.forEach(cb);
@@ -607,7 +757,11 @@ let PromiseManyArray = (_class$5 = class PromiseManyArray {
    * @return
    */
   reload(options) {
-    assert('You are trying to reload an async manyArray before it has been created', this.content);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error('You are trying to reload an async manyArray before it has been created');
+      }
+    })(this.content) : {};
     void this.content.reload(options);
     return this;
   }
@@ -702,12 +856,17 @@ let PromiseManyArray = (_class$5 = class PromiseManyArray {
    * @property meta
    * @public
    */
+  static {
+    decorateMethodV2(this.prototype, "links", [compat]);
+  }
   get meta() {
     return this.content ? this.content.meta : undefined;
   }
 
   //---- Our own stuff
-
+  static {
+    decorateMethodV2(this.prototype, "meta", [compat]);
+  }
   _update(promise, content) {
     if (content !== undefined) {
       this.content = content;
@@ -720,7 +879,8 @@ let PromiseManyArray = (_class$5 = class PromiseManyArray {
   }) {
     return new this(promise, content);
   }
-}, (_applyDecoratedDescriptor(_class$5.prototype, "length", [compat], Object.getOwnPropertyDescriptor(_class$5.prototype, "length"), _class$5.prototype), _applyDecoratedDescriptor(_class$5.prototype, "links", [compat], Object.getOwnPropertyDescriptor(_class$5.prototype, "links"), _class$5.prototype), _applyDecoratedDescriptor(_class$5.prototype, "meta", [compat], Object.getOwnPropertyDescriptor(_class$5.prototype, "meta"), _class$5.prototype)), _class$5);
+  [LegacyPromiseProxy] = true;
+}
 defineSignal(PromiseManyArray.prototype, 'content', null);
 defineSignal(PromiseManyArray.prototype, 'isPending', false);
 defineSignal(PromiseManyArray.prototype, 'isRejected', false);
@@ -731,7 +891,7 @@ defineSignal(PromiseManyArray.prototype, 'isSettled', false);
 // A(identifierArray) since it is not configurable
 // which is preferrable to the `meta` override we used
 // before which required importing all of Ember
-if (macroCondition(getOwnConfig().deprecations.DEPRECATE_COMPUTED_CHAINS)) {
+if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_COMPUTED_CHAINS)) {
   const desc = {
     enumerable: true,
     configurable: false,
@@ -781,21 +941,27 @@ function tapPromise(proxy, promise) {
   `record.relationshipFor(key)`.
 */
 let assertPolymorphicType;
-if (macroCondition(getOwnConfig().env.DEBUG)) {
+if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+  // eslint-disable-next-line @typescript-eslint/no-shadow
   assertPolymorphicType = function assertPolymorphicType(parentIdentifier, parentDefinition, addedIdentifier, store) {
     if (parentDefinition.inverseIsImplicit) {
       return;
     }
     if (parentDefinition.isPolymorphic) {
-      let meta = store.getSchemaDefinitionService().relationshipsDefinitionFor(addedIdentifier)[parentDefinition.inverseKey];
-      assert(`The schema for the relationship '${parentDefinition.inverseKey}' on '${addedIdentifier.type}' type does not implement '${parentDefinition.type}' and thus cannot be assigned to the '${parentDefinition.key}' relationship in '${parentIdentifier.type}'. The definition should specify 'as: "${parentDefinition.type}"' in options.`, meta?.options.as === parentDefinition.type);
+      const meta = store.schema.fields(addedIdentifier)?.get(parentDefinition.inverseKey);
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Expected the schema for the field ${parentDefinition.inverseKey} on ${addedIdentifier.type} to be for a legacy relationship`);
+        }
+      })(!meta || meta.kind === 'belongsTo' || meta.kind === 'hasMany') : {};
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`The schema for the relationship '${parentDefinition.inverseKey}' on '${addedIdentifier.type}' type does not implement '${parentDefinition.type}' and thus cannot be assigned to the '${parentDefinition.key}' relationship in '${parentIdentifier.type}'. The definition should specify 'as: "${parentDefinition.type}"' in options.`);
+        }
+      })(meta?.options.as === parentDefinition.type) : {};
     }
   };
 }
-var _class$4;
-/**
-  @module @ember-data/model
-*/
 function isResourceIdentiferWithRelatedLinks$1(value) {
   return Boolean(value && value.links && value.links.related);
 }
@@ -827,24 +993,26 @@ function isResourceIdentiferWithRelatedLinks$1(value) {
  @class HasManyReference
  @public
  */
-let HasManyReference = (_class$4 = class HasManyReference {
+class HasManyReference {
+  /**
+   * The field name on the parent record for this has-many relationship.
+   *
+   * @property {String} key
+   * @public
+   */
+
+  /**
+   * The type of resource this relationship will contain.
+   *
+   * @property {String} type
+   * @public
+   */
+
+  // unsubscribe tokens given to us by the notification manager
+  ___token;
+  ___identifier;
+  ___relatedTokenMap;
   constructor(store, graph, parentIdentifier, hasManyRelationship, key) {
-    /**
-     * The field name on the parent record for this has-many relationship.
-     *
-     * @property {String} key
-     * @public
-     */
-    /**
-     * The type of resource this relationship will contain.
-     *
-     * @property {String} type
-     * @public
-     */
-    // unsubscribe tokens given to us by the notification manager
-    this.___token = void 0;
-    this.___identifier = void 0;
-    this.___relatedTokenMap = void 0;
     this.graph = graph;
     this.key = key;
     this.hasManyRelationship = hasManyRelationship;
@@ -908,6 +1076,9 @@ let HasManyReference = (_class$4 = class HasManyReference {
     map.clear();
     return [];
   }
+  static {
+    decorateMethodV2(this.prototype, "identifiers", [compat, cached]);
+  }
   _resource() {
     const cache = this.store.cache;
     return cache.getRelationship(this.___identifier, this.key);
@@ -1177,12 +1348,16 @@ let HasManyReference = (_class$4 = class HasManyReference {
     const isResourceData = Array.isArray(dataDoc.data) && dataDoc.data.length > 0 && isMaybeResource(dataDoc.data[0]);
 
     // enforce that one of links, meta or data is present
-    assert(`You must provide at least one of 'links', 'meta' or 'data' when calling hasManyReference.push`, 'links' in dataDoc || 'meta' in dataDoc || 'data' in dataDoc);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You must provide at least one of 'links', 'meta' or 'data' when calling hasManyReference.push`);
+      }
+    })('links' in dataDoc || 'meta' in dataDoc || 'data' in dataDoc) : {};
     const identifiers = !Array.isArray(dataDoc.data) ? [] : isResourceData ? store._push(dataDoc, true) : dataDoc.data.map(i => store.identifierCache.getOrCreateRecordIdentifier(i));
     const {
       identifier
     } = this.hasManyRelationship;
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       const relationshipMeta = this.hasManyRelationship.definition;
       identifiers.forEach(added => {
         assertPolymorphicType(identifier, relationshipMeta, added, store);
@@ -1372,13 +1547,12 @@ let HasManyReference = (_class$4 = class HasManyReference {
     const support = LEGACY_SUPPORT.get(this.___identifier);
     return support.reloadHasMany(this.key, options);
   }
-}, _applyDecoratedDescriptor(_class$4.prototype, "identifiers", [cached, compat], Object.getOwnPropertyDescriptor(_class$4.prototype, "identifiers"), _class$4.prototype), _class$4);
+}
 defineSignal(HasManyReference.prototype, '_ref', 0);
 function isMaybeResource(object) {
   const keys = Object.keys(object).filter(k => k !== 'id' && k !== 'type' && k !== 'lid');
   return keys.length > 0;
 }
-var _class$3;
 function isResourceIdentiferWithRelatedLinks(value) {
   return Boolean(value && value.links && value.links.related);
 }
@@ -1411,7 +1585,7 @@ function isResourceIdentiferWithRelatedLinks(value) {
  @class BelongsToReference
  @public
  */
-let BelongsToReference = (_class$3 = class BelongsToReference {
+class BelongsToReference {
   /**
    * The field name on the parent record for this has-many relationship.
    *
@@ -1514,6 +1688,9 @@ let BelongsToReference = (_class$3 = class BelongsToReference {
    @public
    @return {String} The id of the record in this belongsTo relationship.
    */
+  static {
+    decorateMethodV2(this.prototype, "identifier", [compat, cached]);
+  }
   id() {
     return this.identifier?.id || null;
   }
@@ -1752,7 +1929,7 @@ let BelongsToReference = (_class$3 = class BelongsToReference {
     const {
       identifier
     } = this.belongsToRelationship;
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       if (added) {
         assertPolymorphicType(identifier, this.belongsToRelationship.definition, added, store);
       }
@@ -1933,15 +2110,23 @@ let BelongsToReference = (_class$3 = class BelongsToReference {
     const support = LEGACY_SUPPORT.get(this.___identifier);
     return support.reloadBelongsTo(this.key, options).then(() => this.value());
   }
-}, _applyDecoratedDescriptor(_class$3.prototype, "identifier", [cached, compat], Object.getOwnPropertyDescriptor(_class$3.prototype, "identifier"), _class$3.prototype), _class$3);
+}
 defineSignal(BelongsToReference.prototype, '_ref', 0);
-const LEGACY_SUPPORT = new Map();
+const LEGACY_SUPPORT = getOrSetGlobal('LEGACY_SUPPORT', new Map());
 function lookupLegacySupport(record) {
   const identifier = recordIdentifierFor(record);
-  assert(`Expected a record`, identifier);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected a record`);
+    }
+  })(identifier) : {};
   let support = LEGACY_SUPPORT.get(identifier);
   if (!support) {
-    assert(`Memory Leak Detected`, !record.isDestroyed && !record.isDestroying);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Memory Leak Detected`);
+      }
+    })(!record.isDestroyed && !record.isDestroying) : {};
     support = new LegacySupport(record);
     LEGACY_SUPPORT.set(identifier, support);
     LEGACY_SUPPORT.set(record, support);
@@ -1954,7 +2139,7 @@ class LegacySupport {
     this.store = storeFor(record);
     this.identifier = recordIdentifierFor(record);
     this.cache = peekCache(record);
-    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
+    if (macroCondition(dependencySatisfies('@ember-data/graph', '*'))) {
       const graphFor = importSync('@ember-data/graph/-private').graphFor;
       this.graph = graphFor(this.store);
     }
@@ -1995,7 +2180,11 @@ class LegacySupport {
       return loadingPromise;
     }
     const relationship = this.graph.get(this.identifier, key);
-    assert(`Expected ${key} to be a belongs-to relationship`, isBelongsTo(relationship));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected ${key} to be a belongs-to relationship`);
+      }
+    })(isBelongsTo(relationship)) : {};
     const resource = this.cache.getRelationship(this.identifier, key);
     relationship.state.hasFailedLoadAttempt = false;
     relationship.state.shouldForceReload = true;
@@ -2015,10 +2204,18 @@ class LegacySupport {
     } = this;
     const resource = cache.getRelationship(this.identifier, key);
     const relatedIdentifier = resource && resource.data ? resource.data : null;
-    assert(`Expected a stable identifier`, !relatedIdentifier || isStableIdentifier(relatedIdentifier));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected a stable identifier`);
+      }
+    })(!relatedIdentifier || isStableIdentifier(relatedIdentifier)) : {};
     const store = this.store;
     const relationship = this.graph.get(this.identifier, key);
-    assert(`Expected ${key} to be a belongs-to relationship`, isBelongsTo(relationship));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected ${key} to be a belongs-to relationship`);
+      }
+    })(isBelongsTo(relationship)) : {};
     const isAsync = relationship.definition.isAsync;
     const _belongsToState = {
       key,
@@ -2042,7 +2239,11 @@ class LegacySupport {
         return null;
       } else {
         const toReturn = store._instanceCache.getRecord(relatedIdentifier);
-        assert(`You looked up the '${key}' relationship on a '${identifier.type}' with id ${identifier.id || 'null'} but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (\`belongsTo(<type>, { async: true, inverse: <inverse> })\`)`, toReturn === null || store._instanceCache.recordIsLoaded(relatedIdentifier, true));
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`You looked up the '${key}' relationship on a '${identifier.type}' with id ${identifier.id || 'null'} but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (\`belongsTo(<type>, { async: true, inverse: <inverse> })\`)`);
+          }
+        })(toReturn === null || store._instanceCache.recordIsLoaded(relatedIdentifier, true)) : {};
         return toReturn;
       }
     }
@@ -2064,7 +2265,11 @@ class LegacySupport {
     if (jsonApi.data) {
       for (let i = 0; i < jsonApi.data.length; i++) {
         const relatedIdentifier = jsonApi.data[i];
-        assert(`Expected a stable identifier`, isStableIdentifier(relatedIdentifier));
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`Expected a stable identifier`);
+          }
+        })(isStableIdentifier(relatedIdentifier)) : {};
         if (cache.recordIsLoaded(relatedIdentifier, true)) {
           identifiers.push(relatedIdentifier);
         }
@@ -2073,7 +2278,7 @@ class LegacySupport {
     return [identifiers, jsonApi];
   }
   getManyArray(key, definition) {
-    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
+    if (macroCondition(dependencySatisfies('@ember-data/graph', '*'))) {
       let manyArray = this._manyArrayCache[key];
       if (!definition) {
         definition = this.graph.get(this.identifier, key).definition;
@@ -2100,10 +2305,14 @@ class LegacySupport {
       }
       return manyArray;
     }
-    assert('hasMany only works with the @ember-data/json-api package');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      {
+        throw new Error('hasMany only works with the @ember-data/json-api package');
+      }
+    })() : {};
   }
   fetchAsyncHasMany(key, relationship, manyArray, options) {
-    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
+    if (macroCondition(dependencySatisfies('@ember-data/graph', '*'))) {
       let loadingPromise = this._relationshipPromisesCache[key];
       if (loadingPromise) {
         return loadingPromise;
@@ -2118,10 +2327,14 @@ class LegacySupport {
       this._relationshipPromisesCache[key] = loadingPromise;
       return loadingPromise;
     }
-    assert('hasMany only works with the @ember-data/json-api package');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      {
+        throw new Error('hasMany only works with the @ember-data/json-api package');
+      }
+    })() : {};
   }
   reloadHasMany(key, options) {
-    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
+    if (macroCondition(dependencySatisfies('@ember-data/graph', '*'))) {
       const loadingPromise = this._relationshipPromisesCache[key];
       if (loadingPromise) {
         return loadingPromise;
@@ -2142,10 +2355,14 @@ class LegacySupport {
       }
       return promise;
     }
-    assert(`hasMany only works with the @ember-data/json-api package`);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      {
+        throw new Error(`hasMany only works with the @ember-data/json-api package`);
+      }
+    })() : {};
   }
   getHasMany(key, options) {
-    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
+    if (macroCondition(dependencySatisfies('@ember-data/graph', '*'))) {
       const relationship = this.graph.get(this.identifier, key);
       const {
         definition,
@@ -2162,11 +2379,19 @@ class LegacySupport {
           content: manyArray
         });
       } else {
-        assert(`You looked up the '${key}' relationship on a '${this.identifier.type}' with id ${this.identifier.id || 'null'} but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async ('hasMany(<type>, { async: true, inverse: <inverse> })')`, !anyUnloaded(this.store, relationship));
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`You looked up the '${key}' relationship on a '${this.identifier.type}' with id ${this.identifier.id || 'null'} but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async ('hasMany(<type>, { async: true, inverse: <inverse> })')`);
+          }
+        })(!anyUnloaded(this.store, relationship)) : {};
         return manyArray;
       }
     }
-    assert(`hasMany only works with the @ember-data/json-api package`);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      {
+        throw new Error(`hasMany only works with the @ember-data/json-api package`);
+      }
+    })() : {};
   }
   _updatePromiseProxyFor(kind, key, args) {
     let promiseProxy = this._relationshipProxyCache[key];
@@ -2176,7 +2401,11 @@ class LegacySupport {
         content
       } = args;
       if (promiseProxy) {
-        assert(`Expected a PromiseManyArray`, '_update' in promiseProxy);
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`Expected a PromiseManyArray`);
+          }
+        })('_update' in promiseProxy) : {};
         promiseProxy._update(promise, content);
       } else {
         promiseProxy = this._relationshipProxyCache[key] = new PromiseManyArray(promise, content);
@@ -2188,7 +2417,11 @@ class LegacySupport {
         promise,
         content
       } = args;
-      assert(`Expected a PromiseBelongsTo`, '_belongsToState' in promiseProxy);
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Expected a PromiseBelongsTo`);
+        }
+      })('_belongsToState' in promiseProxy) : {};
       if (content !== undefined) {
         promiseProxy.set('content', content);
       }
@@ -2202,22 +2435,30 @@ class LegacySupport {
   referenceFor(kind, name) {
     let reference = this.references[name];
     if (!reference) {
-      if (macroCondition(!getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
+      if (macroCondition(!dependencySatisfies('@ember-data/graph', '*'))) {
         // TODO @runspired while this feels odd, it is not a regression in capability because we do
         // not today support references pulling from RecordDatas other than our own
         // because of the intimate API access involved. This is something we will need to redesign.
-        assert(`snapshot.belongsTo only supported for @ember-data/json-api`);
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`snapshot.belongsTo only supported for @ember-data/json-api`);
+          }
+        })() : {};
       }
       const {
         graph,
         identifier
       } = this;
       const relationship = graph.get(identifier, name);
-      if (macroCondition(getOwnConfig().env.DEBUG)) {
+      if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
         if (kind) {
           const modelName = identifier.type;
           const actualRelationshipKind = relationship.definition.kind;
-          assert(`You tried to get the '${name}' relationship on a '${modelName}' via record.${kind}('${name}'), but the relationship is of kind '${actualRelationshipKind}'. Use record.${actualRelationshipKind}('${name}') instead.`, actualRelationshipKind === kind);
+          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+            if (!test) {
+              throw new Error(`You tried to get the '${name}' relationship on a '${modelName}' via record.${kind}('${name}'), but the relationship is of kind '${actualRelationshipKind}'. Use record.${actualRelationshipKind}('${name}') instead.`);
+            }
+          })(actualRelationshipKind === kind) : {};
         }
       }
       const relationshipKind = relationship.definition.kind;
@@ -2231,7 +2472,7 @@ class LegacySupport {
     return reference;
   }
   _findHasManyByJsonApiResource(resource, parentIdentifier, relationship, options = {}) {
-    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
+    if (macroCondition(dependencySatisfies('@ember-data/graph', '*'))) {
       if (!resource) {
         return;
       }
@@ -2251,12 +2492,17 @@ class LegacySupport {
       const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this.store, resource);
       const identifiers = resource.data;
       const shouldFindViaLink = resource.links && resource.links.related && (typeof adapter.findHasMany === 'function' || typeof identifiers === 'undefined') && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);
-      const relationshipMeta = this.store.getSchemaDefinitionService().relationshipsDefinitionFor({
+      const field = this.store.schema.fields({
         type: definition.inverseType
-      })[definition.key];
+      }).get(definition.key);
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Expected a hasMany field definition for ${definition.inverseType}.${definition.key}`);
+        }
+      })(field && field.kind === 'hasMany') : {};
       const request = {
         useLink: shouldFindViaLink,
-        field: relationshipMeta,
+        field,
         links: resource.links,
         meta: resource.meta,
         options,
@@ -2265,8 +2511,16 @@ class LegacySupport {
 
       // fetch via link
       if (shouldFindViaLink) {
-        assert(`Expected collection to be an array`, !identifiers || Array.isArray(identifiers));
-        assert(`Expected stable identifiers`, !identifiers || identifiers.every(isStableIdentifier));
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`Expected collection to be an array`);
+          }
+        })(!identifiers || Array.isArray(identifiers)) : {};
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`Expected stable identifiers`);
+          }
+        })(!identifiers || identifiers.every(isStableIdentifier)) : {};
         return this.store.request({
           op: 'findHasMany',
           records: identifiers || [],
@@ -2284,8 +2538,16 @@ class LegacySupport {
       }
       const hasData = hasReceivedData && !isEmpty;
       if (attemptLocalCache || hasData || hasLocalPartialData) {
-        assert(`Expected collection to be an array`, Array.isArray(identifiers));
-        assert(`Expected stable identifiers`, identifiers.every(isStableIdentifier));
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`Expected collection to be an array`);
+          }
+        })(Array.isArray(identifiers)) : {};
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`Expected stable identifiers`);
+          }
+        })(identifiers.every(isStableIdentifier)) : {};
         options.reload = options.reload || !attemptLocalCache || undefined;
         return this.store.request({
           op: 'findHasMany',
@@ -2301,7 +2563,11 @@ class LegacySupport {
       //   TODO if the relationshipIsStale, should we hit the adapter anyway?
       return;
     }
-    assert(`hasMany only works with the @ember-data/json-api package`);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      {
+        throw new Error(`hasMany only works with the @ember-data/json-api package`);
+      }
+    })() : {};
   }
   _findBelongsToByJsonApiResource(resource, parentIdentifier, relationship, options = {}) {
     if (!resource) {
@@ -2316,7 +2582,11 @@ class LegacySupport {
       return this._pending[key];
     }
     const identifier = resource.data ? resource.data : null;
-    assert(`Expected a stable identifier`, !identifier || isStableIdentifier(identifier));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected a stable identifier`);
+      }
+    })(!identifier || isStableIdentifier(identifier)) : {};
     const {
       isStale,
       hasDematerializedInverse,
@@ -2326,11 +2596,15 @@ class LegacySupport {
     } = relationship.state;
     const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this.store, resource);
     const shouldFindViaLink = resource.links?.related && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);
-    const relationshipMeta = this.store.getSchemaDefinitionService().relationshipsDefinitionFor(this.identifier)[relationship.definition.key];
-    assert(`Attempted to access a belongsTo relationship but no definition exists for it`, relationshipMeta);
+    const field = this.store.schema.fields(this.identifier).get(relationship.definition.key);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Attempted to access a belongsTo relationship but no definition exists for it`);
+      }
+    })(field && field.kind === 'belongsTo') : {};
     const request = {
       useLink: shouldFindViaLink,
-      field: relationshipMeta,
+      field,
       links: resource.links,
       meta: resource.meta,
       options,
@@ -2371,7 +2645,11 @@ class LegacySupport {
 
     // we may need to fetch
     if (identifier) {
-      assert(`Cannot fetch belongs-to relationship with no information`, identifier);
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Cannot fetch belongs-to relationship with no information`);
+        }
+      })(identifier) : {};
       options.reload = options.reload || !attemptLocalCache || undefined;
       this._pending[key] = this.store.request({
         op: 'findBelongsTo',
@@ -2459,7 +2737,11 @@ function extractIdentifierFromRecord(record) {
 }
 function anyUnloaded(store, relationship) {
   const graph = store._graph;
-  assert(`Expected a Graph instance to be available`, graph);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected a Graph instance to be available`);
+    }
+  })(graph) : {};
   const relationshipData = graph.getData(relationship.identifier, relationship.definition.key);
   const state = relationshipData.data;
   const cache = store._instanceCache;
@@ -2473,7 +2755,11 @@ function areAllInverseRecordsLoaded(store, resource) {
   const instanceCache = store._instanceCache;
   const identifiers = resource.data;
   if (Array.isArray(identifiers)) {
-    assert(`Expected stable identifiers`, identifiers.every(isStableIdentifier));
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected stable identifiers`);
+      }
+    })(identifiers.every(isStableIdentifier)) : {};
     // treat as collection
     // check for unloaded records
     return identifiers.every(identifier => instanceCache.recordIsLoaded(identifier));
@@ -2481,26 +2767,16 @@ function areAllInverseRecordsLoaded(store, resource) {
 
   // treat as single resource
   if (!identifiers) return true;
-  assert(`Expected stable identifiers`, isStableIdentifier(identifiers));
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected stable identifiers`);
+    }
+  })(isStableIdentifier(identifiers)) : {};
   return instanceCache.recordIsLoaded(identifiers);
 }
 function isBelongsTo(relationship) {
   return relationship.definition.kind === 'belongsTo';
 }
-function _initializerDefineProperty(target, property, descriptor, context) {
-  if (!descriptor) return;
-  Object.defineProperty(target, property, {
-    enumerable: descriptor.enumerable,
-    configurable: descriptor.configurable,
-    writable: descriptor.writable,
-    value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
-  });
-}
-var _dec, _dec2, _dec3, _dec4, _class$2, _descriptor, _descriptor2;
-
-/**
-  @module @ember-data/model
-*/
 
 // we force the type here to our own construct because mixin and extend patterns
 // lose generic signatures. We also do this because we need to Omit `clear` from
@@ -2582,40 +2858,7 @@ const ArrayProxyWithCustomOverrides = ArrayProxy;
   @public
   @extends Ember.ArrayProxy
  */
-let Errors = (_dec = computed(), _dec2 = mapBy('content', 'message'), _dec3 = computed(), _dec4 = not('length'), (_class$2 = class Errors extends ArrayProxyWithCustomOverrides {
-  constructor(...args) {
-    super(...args);
-    /**
-      An array containing all of the error messages for this
-      record. This is useful for displaying all errors to the user.
-       ```handlebars
-      {{#each @model.errors.messages as |message|}}
-        <div class="error">
-          {{message}}
-        </div>
-      {{/each}}
-      ```
-       @property messages
-      @public
-      @type {Array}
-    */
-    _initializerDefineProperty(this, "messages", _descriptor, this);
-    /**
-      Total number of errors.
-       @property length
-      @type {Number}
-      @public
-      @readOnly
-    */
-    /**
-      `true` if we have no errors.
-       @property isEmpty
-      @type {Boolean}
-      @public
-      @readOnly
-    */
-    _initializerDefineProperty(this, "isEmpty", _descriptor2, this);
-  }
+class Errors extends ArrayProxyWithCustomOverrides {
   /**
     @property errorsByAttributeName
     @type {MapWithDefault}
@@ -2642,6 +2885,9 @@ let Errors = (_dec = computed(), _dec2 = mapBy('content', 'message'), _dec3 = co
     @param {String} attribute
     @return {Array}
   */
+  static {
+    decorateMethodV2(this.prototype, "errorsByAttributeName", [computed()]);
+  }
   errorsFor(attribute) {
     const map = this.errorsByAttributeName;
     let errors = map.get(attribute);
@@ -2657,6 +2903,25 @@ let Errors = (_dec = computed(), _dec2 = mapBy('content', 'message'), _dec3 = co
     get(errors, '[]');
     return errors;
   }
+
+  /**
+    An array containing all of the error messages for this
+    record. This is useful for displaying all errors to the user.
+     ```handlebars
+    {{#each @model.errors.messages as |message|}}
+      <div class="error">
+        {{message}}
+      </div>
+    {{/each}}
+    ```
+     @property messages
+    @public
+    @type {Array}
+  */
+  static {
+    decorateFieldV2(this.prototype, "messages", [mapBy('content', 'message')]);
+  }
+  #messages = (initializeDeferredDecorator(this, "messages"), void 0);
   /**
     @property content
     @type {Array}
@@ -2670,6 +2935,9 @@ let Errors = (_dec = computed(), _dec2 = mapBy('content', 'message'), _dec3 = co
     @method unknownProperty
     @private
   */
+  static {
+    decorateMethodV2(this.prototype, "content", [computed()]);
+  }
   unknownProperty(attribute) {
     const errors = this.errorsFor(attribute);
     if (errors.length === 0) {
@@ -2677,6 +2945,26 @@ let Errors = (_dec = computed(), _dec2 = mapBy('content', 'message'), _dec3 = co
     }
     return errors;
   }
+
+  /**
+    Total number of errors.
+     @property length
+    @type {Number}
+    @public
+    @readOnly
+  */
+
+  /**
+    `true` if we have no errors.
+     @property isEmpty
+    @type {Boolean}
+    @public
+    @readOnly
+  */
+  static {
+    decorateFieldV2(this.prototype, "isEmpty", [not('length')]);
+  }
+  #isEmpty = (initializeDeferredDecorator(this, "isEmpty"), void 0);
   /**
    Manually adds errors to the record. This will trigger the `becameInvalid` event/ lifecycle method on
     the record and transition the record into an `invalid` state.
@@ -2835,9 +3123,7 @@ let Errors = (_dec = computed(), _dec2 = mapBy('content', 'message'), _dec3 = co
   /**
     Checks if there are error messages for the given attribute.
      ```app/controllers/user/edit.js
-    import Controller from '@ember/controller';
-    import { action } from '@ember/object';
-     export default class UserEditController extends Controller {
+    export default class UserEditController extends Controller {
       @action
       save(user) {
         if (user.errors.has('email')) {
@@ -2855,17 +3141,7 @@ let Errors = (_dec = computed(), _dec2 = mapBy('content', 'message'), _dec3 = co
   has(attribute) {
     return this.errorsFor(attribute).length > 0;
   }
-}, (_applyDecoratedDescriptor(_class$2.prototype, "errorsByAttributeName", [_dec], Object.getOwnPropertyDescriptor(_class$2.prototype, "errorsByAttributeName"), _class$2.prototype), _descriptor = _applyDecoratedDescriptor(_class$2.prototype, "messages", [_dec2], {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  initializer: null
-}), _applyDecoratedDescriptor(_class$2.prototype, "content", [_dec3], Object.getOwnPropertyDescriptor(_class$2.prototype, "content"), _class$2.prototype), _descriptor2 = _applyDecoratedDescriptor(_class$2.prototype, "isEmpty", [_dec4], {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  initializer: null
-})), _class$2));
+}
 function rollbackAttributes() {
   const {
     currentState
@@ -2898,7 +3174,11 @@ function reload(options = {}) {
   options.isReloading = true;
   options.reload = true;
   const identifier = recordIdentifierFor$1(this);
-  assert(`You cannot reload a record without an ID`, identifier.id);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`You cannot reload a record without an ID`);
+    }
+  })(identifier.id) : {};
   this.isReloading = true;
   const promise = this[RecordStore].request({
     op: 'findRecord',
@@ -2973,7 +3253,11 @@ function notifyChanges(identifier, value, key, record, store) {
   } else if (value === 'relationships') {
     if (key) {
       const meta = record.constructor.relationshipsByName.get(key);
-      assert(`Expected to find a relationship for ${key} on ${identifier.type}`, meta);
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Expected to find a relationship for ${key} on ${identifier.type}`);
+        }
+      })(meta) : {};
       notifyRelationship(identifier, key, record, meta);
     } else {
       record.eachRelationship((name, meta) => {
@@ -3002,8 +3286,16 @@ function notifyRelationship(identifier, key, record, meta) {
       //We need to notifyPropertyChange in the adding case because we need to make sure
       //we fetch the newly added record in case it is unloaded
       //TODO(Igor): Consider whether we could do this only if the record state is unloaded
-      assert(`Expected options to exist on relationship meta`, meta.options);
-      assert(`Expected async to exist on relationship meta options`, 'async' in meta.options);
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Expected options to exist on relationship meta`);
+        }
+      })(meta.options) : {};
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Expected async to exist on relationship meta options`);
+        }
+      })('async' in meta.options) : {};
       if (meta.options.async) {
         record.notifyPropertyChange(key);
       }
@@ -3017,7 +3309,6 @@ function notifyAttribute(store, identifier, key, record) {
     record.notifyPropertyChange(key);
   }
 }
-var _class$1;
 const SOURCE_POINTER_REGEXP = /^\/?data\/(attributes|relationships)\/(.*)/;
 const SOURCE_POINTER_PRIMARY_REGEXP = /^\/?data/;
 const PRIMARY_ATTRIBUTE_KEY = 'base';
@@ -3102,7 +3393,7 @@ root
 
   @internal
 */
-let RecordState = (_class$1 = class RecordState {
+class RecordState {
   constructor(record) {
     const store = storeFor$1(record);
     const identity = recordIdentifierFor(record);
@@ -3199,7 +3490,11 @@ let RecordState = (_class$1 = class RecordState {
     notifySignal(this, key);
   }
   updateInvalidErrors(errors) {
-    assert(`Expected the Cache instance for ${this.identifier.lid}  to implement getErrors(identifier)`, typeof this.cache.getErrors === 'function');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected the Cache instance for ${this.identifier.lid}  to implement getErrors(identifier)`);
+      }
+    })(typeof this.cache.getErrors === 'function') : {};
     const jsonApiErrors = this.cache.getErrors(this.identifier);
     errors.clear();
     for (let i = 0; i < jsonApiErrors.length; i++) {
@@ -3214,7 +3509,11 @@ let RecordState = (_class$1 = class RecordState {
         }
         if (key) {
           const errMsg = error.detail || error.title;
-          assert(`Expected field error to have a detail or title to use as the message`, errMsg);
+          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+            if (!test) {
+              throw new Error(`Expected field error to have a detail or title to use as the message`);
+            }
+          })(errMsg) : {};
           errors.add(key, errMsg);
         }
       }
@@ -3230,16 +3529,26 @@ let RecordState = (_class$1 = class RecordState {
   get isLoading() {
     return !this.isLoaded && this.pendingCount > 0 && this.fulfilledCount === 0;
   }
+  static {
+    decorateMethodV2(this.prototype, "isLoading", [tagged]);
+  }
   get isLoaded() {
     if (this.isNew) {
       return true;
     }
     return this.fulfilledCount > 0 || !this.isEmpty;
   }
+  static {
+    decorateMethodV2(this.prototype, "isLoaded", [tagged]);
+  }
   get isSaved() {
     const rd = this.cache;
     if (this.isDeleted) {
-      assert(`Expected Cache to implement isDeletionCommitted()`, typeof rd.isDeletionCommitted === 'function');
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Expected Cache to implement isDeletionCommitted()`);
+        }
+      })(typeof rd.isDeletionCommitted === 'function') : {};
       return rd.isDeletionCommitted(this.identifier);
     }
     if (this.isNew || this.isEmpty || !this.isValid || this.isDirty || this.isLoading) {
@@ -3247,26 +3556,53 @@ let RecordState = (_class$1 = class RecordState {
     }
     return true;
   }
+  static {
+    decorateMethodV2(this.prototype, "isSaved", [tagged]);
+  }
   get isEmpty() {
     const rd = this.cache;
     // TODO this is not actually an RFC'd concept. Determine the
     // correct heuristic to replace this with.
-    assert(`Expected Cache to implement isEmpty()`, typeof rd.isEmpty === 'function');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected Cache to implement isEmpty()`);
+      }
+    })(typeof rd.isEmpty === 'function') : {};
     return !this.isNew && rd.isEmpty(this.identifier);
   }
+  static {
+    decorateMethodV2(this.prototype, "isEmpty", [tagged]);
+  }
   get isNew() {
     const rd = this.cache;
-    assert(`Expected Cache to implement isNew()`, typeof rd.isNew === 'function');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected Cache to implement isNew()`);
+      }
+    })(typeof rd.isNew === 'function') : {};
     return rd.isNew(this.identifier);
   }
+  static {
+    decorateMethodV2(this.prototype, "isNew", [tagged]);
+  }
   get isDeleted() {
     const rd = this.cache;
-    assert(`Expected Cache to implement isDeleted()`, typeof rd.isDeleted === 'function');
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected Cache to implement isDeleted()`);
+      }
+    })(typeof rd.isDeleted === 'function') : {};
     return rd.isDeleted(this.identifier);
   }
+  static {
+    decorateMethodV2(this.prototype, "isDeleted", [tagged]);
+  }
   get isValid() {
     return this.record.errors.length === 0;
   }
+  static {
+    decorateMethodV2(this.prototype, "isValid", [tagged]);
+  }
   get isDirty() {
     const rd = this.cache;
     if (this.isEmpty || rd.isDeletionCommitted(this.identifier) || this.isDeleted && this.isNew) {
@@ -3274,6 +3610,9 @@ let RecordState = (_class$1 = class RecordState {
     }
     return this.isDeleted || this.isNew || rd.hasChangedAttrs(this.identifier);
   }
+  static {
+    decorateMethodV2(this.prototype, "isDirty", [tagged]);
+  }
   get isError() {
     const errorReq = this._errorRequests[this._errorRequests.length - 1];
     if (!errorReq) {
@@ -3282,6 +3621,9 @@ let RecordState = (_class$1 = class RecordState {
       return true;
     }
   }
+  static {
+    decorateMethodV2(this.prototype, "isError", [tagged]);
+  }
   get adapterError() {
     const request = this._lastError;
     if (!request) {
@@ -3289,9 +3631,15 @@ let RecordState = (_class$1 = class RecordState {
     }
     return request.state === 'rejected' && request.response.data;
   }
+  static {
+    decorateMethodV2(this.prototype, "adapterError", [tagged]);
+  }
   get isPreloaded() {
     return !this.isEmpty && this.isLoading;
   }
+  static {
+    decorateMethodV2(this.prototype, "isPreloaded", [cached]);
+  }
   get stateName() {
     // we might be empty while loading so check this first
     if (this.isLoading) {
@@ -3336,6 +3684,9 @@ let RecordState = (_class$1 = class RecordState {
       return 'root.loaded.saved';
     }
   }
+  static {
+    decorateMethodV2(this.prototype, "stateName", [cached]);
+  }
   get dirtyType() {
     // we might be empty while loading so check this first
     if (this.isLoading || this.isEmpty) {
@@ -3358,15 +3709,21 @@ let RecordState = (_class$1 = class RecordState {
       return '';
     }
   }
-}, (_applyDecoratedDescriptor(_class$1.prototype, "isLoading", [tagged], Object.getOwnPropertyDescriptor(_class$1.prototype, "isLoading"), _class$1.prototype), _applyDecoratedDescriptor(_class$1.prototype, "isLoaded", [tagged], Object.getOwnPropertyDescriptor(_class$1.prototype, "isLoaded"), _class$1.prototype), _applyDecoratedDescriptor(_class$1.prototype, "isSaved", [tagged], Object.getOwnPropertyDescriptor(_class$1.prototype, "isSaved"), _class$1.prototype), _applyDecoratedDescriptor(_class$1.prototype, "isEmpty", [tagged], Object.getOwnPropertyDescriptor(_class$1.prototype, "isEmpty"), _class$1.prototype), _applyDecoratedDescriptor(_class$1.prototype, "isNew", [tagged], Object.getOwnPropertyDescriptor(_class$1.prototype, "isNew"), _class$1.prototype), _applyDecoratedDescriptor(_class$1.prototype, "isDeleted", [tagged], Object.getOwnPropertyDescriptor(_class$1.prototype, "isDeleted"), _class$1.prototype), _applyDecoratedDescriptor(_class$1.prototype, "isValid", [tagged], Object.getOwnPropertyDescriptor(_class$1.prototype, "isValid"), _class$1.prototype), _applyDecoratedDescriptor(_class$1.prototype, "isDirty", [tagged], Object.getOwnPropertyDescriptor(_class$1.prototype, "isDirty"), _class$1.prototype), _applyDecoratedDescriptor(_class$1.prototype, "isError", [tagged], Object.getOwnPropertyDescriptor(_class$1.prototype, "isError"), _class$1.prototype), _applyDecoratedDescriptor(_class$1.prototype, "adapterError", [tagged], Object.getOwnPropertyDescriptor(_class$1.prototype, "adapterError"), _class$1.prototype), _applyDecoratedDescriptor(_class$1.prototype, "isPreloaded", [cached], Object.getOwnPropertyDescriptor(_class$1.prototype, "isPreloaded"), _class$1.prototype), _applyDecoratedDescriptor(_class$1.prototype, "stateName", [cached], Object.getOwnPropertyDescriptor(_class$1.prototype, "stateName"), _class$1.prototype), _applyDecoratedDescriptor(_class$1.prototype, "dirtyType", [cached], Object.getOwnPropertyDescriptor(_class$1.prototype, "dirtyType"), _class$1.prototype)), _class$1);
+  static {
+    decorateMethodV2(this.prototype, "dirtyType", [cached]);
+  }
+}
 defineSignal(RecordState.prototype, 'isSaving', false);
 function notifyErrorsStateChanged(state) {
   state.notify('isValid');
   state.notify('isError');
   state.notify('adapterError');
 }
-var _class, _Model;
-// instantiateRecord as well.
+
+/**
+  @module @ember-data/model
+ */
+
 /*
  * This decorator allows us to lazily compute
  * an expensive getter on first-access and thereafter
@@ -3413,11 +3770,12 @@ function computeOnce(target, propertyName, desc) {
   @public
   @extends Ember.EmberObject
 */
-let Model = (_class = (_Model = class Model extends EmberObject {
+
+class Model extends EmberObject {
   // set during create by the store
 
   init(options) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       if (!options?._secretInit && !options?._createProps) {
         throw new Error('You should not call `create` on a model. Instead, call `store.createRecord` with the attributes you would like to set.');
       }
@@ -3431,7 +3789,7 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     this[RecordStore] = store;
     const identity = _secretInit.identifier;
     _secretInit.cb(this, _secretInit.cache, identity, _secretInit.store);
-    this.___recordState = macroCondition(getOwnConfig().env.DEBUG) ? new RecordState(this) : null;
+    this.___recordState = macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? new RecordState(this) : null;
     this.setProperties(createProps);
     const notifications = store.notifications;
     this.___private_notifications = notifications.subscribe(identity, (identifier, type, field) => {
@@ -3439,7 +3797,7 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     });
   }
 
-  // @ts-expect-error destroy should not return a value
+  // @ts-expect-error destroy should not return a value, but ember's types force it to
   destroy() {
     const identifier = recordIdentifierFor$1(this);
     this.___recordState?.destroy();
@@ -3490,6 +3848,9 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     @type {Boolean}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "isEmpty", [compat]);
+  }
   get isLoading() {
     return this.currentState.isLoading;
   }
@@ -3512,6 +3873,9 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     @type {Boolean}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "isLoading", [compat]);
+  }
   get isLoaded() {
     return this.currentState.isLoaded;
   }
@@ -3537,6 +3901,9 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     @type {Boolean}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "isLoaded", [compat]);
+  }
   get hasDirtyAttributes() {
     return this.currentState.isDirty;
   }
@@ -3561,6 +3928,9 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     @type {Boolean}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "hasDirtyAttributes", [compat]);
+  }
   get isSaving() {
     return this.currentState.isSaving;
   }
@@ -3597,6 +3967,9 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     @type {Boolean}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "isSaving", [compat]);
+  }
   get isDeleted() {
     return this.currentState.isDeleted;
   }
@@ -3619,6 +3992,9 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     @type {Boolean}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "isDeleted", [compat]);
+  }
   get isNew() {
     return this.currentState.isNew;
   }
@@ -3632,6 +4008,9 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     @type {Boolean}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "isNew", [compat]);
+  }
   get isValid() {
     return this.currentState.isValid;
   }
@@ -3653,6 +4032,9 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     @type {String}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "isValid", [compat]);
+  }
   get dirtyType() {
     return this.currentState.dirtyType;
   }
@@ -3674,11 +4056,17 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     @type {Boolean}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "dirtyType", [compat]);
+  }
   get isError() {
     return this.currentState.isError;
   }
+  static {
+    decorateMethodV2(this.prototype, "isError", [compat]);
+  }
   set isError(v) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       throw new Error(`isError is not directly settable`);
     }
   }
@@ -3718,7 +4106,7 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     // this guard exists, because some dev-only deprecation code
     // (addListener via validatePropertyInjections) invokes toString before the
     // object is real.
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       try {
         return recordIdentifierFor$1(this).id;
       } catch {
@@ -3727,11 +4115,18 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     }
     return recordIdentifierFor$1(this).id;
   }
+  static {
+    decorateMethodV2(this.prototype, "id", [tagged]);
+  }
   set id(id) {
     const normalizedId = coerceId(id);
     const identifier = recordIdentifierFor$1(this);
     const didChange = normalizedId !== identifier.id;
-    assert(`Cannot set ${identifier.type} record's id to ${id}, because id is already ${identifier.id}`, !didChange || identifier.id === null);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Cannot set ${identifier.type} record's id to ${id}, because id is already ${identifier.id}`);
+      }
+    })(!didChange || identifier.id === null) : {};
     if (normalizedId !== null && didChange) {
       this.store._instanceCache.setRecordId(identifier, normalizedId);
       this.store.notifications.notify(identifier, 'identity');
@@ -3753,13 +4148,16 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     // when using legacy/classic ember classes. Basically: lazy in prod and eager in dev.
     // so we do this to try to steer folks to the nicer "dont user currentState"
     // error.
-    if (macroCondition(!getOwnConfig().env.DEBUG)) {
+    if (macroCondition(!getGlobalConfig().WarpDrive.env.DEBUG)) {
       if (!this.___recordState) {
         this.___recordState = new RecordState(this);
       }
     }
     return this.___recordState;
   }
+  static {
+    decorateMethodV2(this.prototype, "currentState", [tagged]);
+  }
   set currentState(_v) {
     throw new Error('cannot set currentState');
   }
@@ -3829,9 +4227,15 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     @public
     @type {AdapterError}
   */
+  static {
+    decorateMethodV2(this.prototype, "errors", [computeOnce]);
+  }
   get adapterError() {
     return this.currentState.adapterError;
   }
+  static {
+    decorateMethodV2(this.prototype, "adapterError", [compat]);
+  }
   set adapterError(v) {
     throw new Error(`adapterError is not directly settable`);
   }
@@ -3848,7 +4252,6 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     @param {Object} options
     @return {Object} an object whose values are primitive JSON values only
   */
-
   /*
     We hook the default implementation to ensure
     our tagged properties are properly notified
@@ -3857,7 +4260,7 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     to trigger their flush. We wouldn't need to
     super in 4.0+ where sync observers are removed.
    */
-  // @ts-expect-error no return is necessary
+  // @ts-expect-error no return is necessary, but Ember's types are forcing it
   notifyPropertyChange(prop) {
     notifySignal(this, prop);
     super.notifyPropertyChange(prop);
@@ -3986,7 +4389,6 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     @method _createSnapshot
     @private
   */
-
   // TODO @deprecate in favor of a public API or examples of how to test successfully
 
   /**
@@ -4046,7 +4448,11 @@ let Model = (_class = (_Model = class Model extends EmberObject {
   */
 
   attr() {
-    assert('The `attr` method is not available on Model, a Snapshot was probably expected. Are you passing a Model instead of a Snapshot to your serializer?', false);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      {
+        throw new Error('The `attr` method is not available on Model, a Snapshot was probably expected. Are you passing a Model instead of a Snapshot to your serializer?');
+      }
+    })() : {};
   }
 
   /**
@@ -4179,6 +4585,45 @@ let Model = (_class = (_Model = class Model extends EmberObject {
   eachAttribute(callback, binding) {
     this.constructor.eachAttribute(callback, binding);
   }
+  static isModel = true;
+
+  /**
+    Create should only ever be called by the store. To create an instance of a
+    `Model` in a dirty state use `store.createRecord`.
+    To create instances of `Model` in a clean state, use `store.push`
+     @method create
+    @private
+    @static
+  */
+
+  /**
+   Represents the model's class name as a string. This can be used to look up the model's class name through
+   `Store`'s modelFor method.
+    `modelName` is generated for you by EmberData. It will be a lowercased, dasherized string.
+   For example:
+    ```javascript
+   store.modelFor('post').modelName; // 'post'
+   store.modelFor('blog-post').modelName; // 'blog-post'
+   ```
+    The most common place you'll want to access `modelName` is in your serializer's `payloadKeyFromModelName` method. For example, to change payload
+   keys to underscore (instead of dasherized), you might use the following code:
+    ```javascript
+   import RESTSerializer from '@ember-data/serializer/rest';
+   import { underscore } from '<app-name>/utils/string-utils';
+    export default const PostSerializer = RESTSerializer.extend({
+     payloadKeyFromModelName(modelName) {
+       return underscore(modelName);
+     }
+   });
+   ```
+   @property modelName
+    @public
+   @type String
+   @readonly
+   @static
+  */
+  static modelName = null;
+
   /*
    These class methods below provide relationship
    introspection abilities about relationships.
@@ -4211,12 +4656,20 @@ let Model = (_class = (_Model = class Model extends EmberObject {
    @return {Model} the type of the relationship, or undefined
    */
   static typeForRelationship(name, store) {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     const relationship = this.relationshipsByName.get(name);
     return relationship && store.modelFor(relationship.type);
   }
   static get inverseMap() {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     return Object.create(null);
   }
 
@@ -4246,8 +4699,15 @@ let Model = (_class = (_Model = class Model extends EmberObject {
    @param {Store} store
    @return {Object} the inverse relationship, or null
    */
+  static {
+    decorateMethodV2(this, "inverseMap", [computeOnce]);
+  }
   static inverseFor(name, store) {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     const inverseMap = this.inverseMap;
     if (inverseMap[name]) {
       return inverseMap[name];
@@ -4260,30 +4720,47 @@ let Model = (_class = (_Model = class Model extends EmberObject {
 
   //Calculate the inverse, ignoring the cache
   static _findInverseFor(name, store) {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     const relationship = this.relationshipsByName.get(name);
-    assert(`No relationship named '${name}' on '${this.modelName}' exists.`, relationship);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`No relationship named '${name}' on '${this.modelName}' exists.`);
+      }
+    })(relationship) : {};
     if (!relationship) {
       return null;
     }
     const {
       options
     } = relationship;
-    assert(`Expected the relationship ${name} on ${this.modelName} to define an inverse.`, options.inverse === null || typeof options.inverse === 'string' && options.inverse.length > 0);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected the relationship ${name} on ${this.modelName} to define an inverse.`);
+      }
+    })(options.inverse === null || typeof options.inverse === 'string' && options.inverse.length > 0) : {};
     if (options.inverse === null) {
       return null;
     }
-    const schemaExists = store.schema.doesTypeExist(relationship.type);
-    assert(`No associated schema found for '${relationship.type}' while calculating the inverse of ${name} on ${this.modelName}`, schemaExists);
+    const schemaExists = store.schema.hasResource(relationship);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`No associated schema found for '${relationship.type}' while calculating the inverse of ${name} on ${this.modelName}`);
+      }
+    })(schemaExists) : {};
     if (!schemaExists) {
       return null;
     }
-    const inverseSchemas = store.schema.relationshipsDefinitionFor({
-      type: relationship.type
-    });
-    const inverseSchema = inverseSchemas[options.inverse];
-    assert(`No inverse relationship found for '${name}' on '${this.modelName}'`, inverseSchema !== undefined);
-    return inverseSchema || null;
+    const inverseField = store.schema.fields(relationship).get(options.inverse);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`No inverse relationship found for '${name}' on '${this.modelName}'`);
+      }
+    })(inverseField && (inverseField.kind === 'belongsTo' || inverseField.kind === 'hasMany')) : {};
+    return inverseField || null;
   }
 
   /**
@@ -4321,7 +4798,11 @@ let Model = (_class = (_Model = class Model extends EmberObject {
    */
 
   static get relationships() {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     const map = new Map();
     const relationshipsByName = this.relationshipsByName;
 
@@ -4365,8 +4846,15 @@ let Model = (_class = (_Model = class Model extends EmberObject {
    @type Object
    @readOnly
    */
+  static {
+    decorateMethodV2(this, "relationships", [computeOnce]);
+  }
   static get relationshipNames() {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     const names = {
       hasMany: [],
       belongsTo: []
@@ -4404,8 +4892,15 @@ let Model = (_class = (_Model = class Model extends EmberObject {
    @type Array
    @readOnly
    */
+  static {
+    decorateMethodV2(this, "relationshipNames", [computeOnce]);
+  }
   static get relatedTypes() {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     const types = [];
     const rels = this.relationshipsObject;
     const relationships = Object.keys(rels);
@@ -4451,8 +4946,15 @@ let Model = (_class = (_Model = class Model extends EmberObject {
    @type Map
    @readOnly
    */
+  static {
+    decorateMethodV2(this, "relatedTypes", [computeOnce]);
+  }
   static get relationshipsByName() {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     const map = new Map();
     const rels = this.relationshipsObject;
     const relationships = Object.keys(rels);
@@ -4463,8 +4965,15 @@ let Model = (_class = (_Model = class Model extends EmberObject {
     }
     return map;
   }
+  static {
+    decorateMethodV2(this, "relationshipsByName", [computeOnce]);
+  }
   static get relationshipsObject() {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     const relationships = Object.create(null);
     const modelName = this.modelName;
     this.eachComputedProperty((name, meta) => {
@@ -4474,10 +4983,17 @@ let Model = (_class = (_Model = class Model extends EmberObject {
       // TODO deprecate key being here
       meta.key = name;
       meta.name = name;
-      meta.parentModelName = modelName;
       relationships[name] = meta;
-      assert(`Expected options in meta`, meta.options && typeof meta.options === 'object');
-      assert(`You should not specify both options.as and options.inverse as null on ${modelName}.${meta.name}, as if there is no inverse field there is no abstract type to conform to. You may have intended for this relationship to be polymorphic, or you may have mistakenly set inverse to null.`, !(meta.options.inverse === null && meta.options.as?.length));
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Expected options in meta`);
+        }
+      })(meta.options && typeof meta.options === 'object') : {};
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`You should not specify both options.as and options.inverse as null on ${modelName}.${meta.name}, as if there is no inverse field there is no abstract type to conform to. You may have intended for this relationship to be polymorphic, or you may have mistakenly set inverse to null.`);
+        }
+      })(!(meta.options.inverse === null && meta.options.as?.length)) : {};
     });
     return relationships;
   }
@@ -4514,8 +5030,15 @@ let Model = (_class = (_Model = class Model extends EmberObject {
    @type Map
    @readOnly
    */
+  static {
+    decorateMethodV2(this, "relationshipsObject", [computeOnce]);
+  }
   static get fields() {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     const map = new Map();
     this.eachComputedProperty((name, meta) => {
       if (isRelationshipSchema(meta)) {
@@ -4537,8 +5060,15 @@ let Model = (_class = (_Model = class Model extends EmberObject {
    @param {Function} callback the callback to invoke
    @param {any} binding the value to which the callback's `this` should be bound
    */
+  static {
+    decorateMethodV2(this, "fields", [computeOnce]);
+  }
   static eachRelationship(callback, binding) {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     this.relationshipsByName.forEach((relationship, name) => {
       callback.call(binding, name, relationship);
     });
@@ -4556,7 +5086,11 @@ let Model = (_class = (_Model = class Model extends EmberObject {
    @param {any} binding the value to which the callback's `this` should be bound
    */
   static eachRelatedType(callback, binding) {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     const relationshipTypes = this.relatedTypes;
     for (let i = 0; i < relationshipTypes.length; i++) {
       const type = relationshipTypes[i];
@@ -4571,7 +5105,11 @@ let Model = (_class = (_Model = class Model extends EmberObject {
    * @deprecated
    */
   static determineRelationshipType(knownSide, store) {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     const knownKey = knownSide.name;
     const knownKind = knownSide.kind;
     const inverse = this.inverseFor(knownKey, store);
@@ -4621,11 +5159,19 @@ let Model = (_class = (_Model = class Model extends EmberObject {
    @readOnly
    */
   static get attributes() {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     const map = new Map();
     this.eachComputedProperty((name, meta) => {
       if (isAttributeSchema(meta)) {
-        assert("You may not set `id` as an attribute on your model. Please remove any lines that look like: `id: attr('<type>')` from " + this.toString(), name !== 'id');
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error("You may not set `id` as an attribute on your model. Please remove any lines that look like: `id: attr('<type>')` from " + this.toString());
+          }
+        })(name !== 'id') : {};
 
         // TODO deprecate key being here
         meta.key = name;
@@ -4666,8 +5212,15 @@ let Model = (_class = (_Model = class Model extends EmberObject {
    @type {Map}
    @readOnly
    */
+  static {
+    decorateMethodV2(this, "attributes", [computeOnce]);
+  }
   static get transformedAttributes() {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     const map = new Map();
     this.eachAttribute((name, meta) => {
       if (meta.type) {
@@ -4711,8 +5264,15 @@ let Model = (_class = (_Model = class Model extends EmberObject {
    @param {Object} [binding] the value to which the callback's `this` should be bound
    @static
    */
+  static {
+    decorateMethodV2(this, "transformedAttributes", [computeOnce]);
+  }
   static eachAttribute(callback, binding) {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     this.attributes.forEach((meta, name) => {
       callback.call(binding, name, meta);
     });
@@ -4754,7 +5314,11 @@ let Model = (_class = (_Model = class Model extends EmberObject {
    @static
    */
   static eachTransformedAttribute(callback, binding) {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     this.transformedAttributes.forEach((type, name) => {
       callback.call(binding, name, type);
     });
@@ -4767,11 +5331,18 @@ let Model = (_class = (_Model = class Model extends EmberObject {
    @static
    */
   static toString() {
-    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Accessing schema information on Models without looking up the model via the store is disallowed.`);
+      }
+    })(this.modelName) : {};
     return `model:${this.modelName}`;
   }
-}, _Model.isModel = true, _Model.modelName = null, _Model), (_applyDecoratedDescriptor(_class.prototype, "isEmpty", [compat], Object.getOwnPropertyDescriptor(_class.prototype, "isEmpty"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "isLoading", [compat], Object.getOwnPropertyDescriptor(_class.prototype, "isLoading"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "isLoaded", [compat], Object.getOwnPropertyDescriptor(_class.prototype, "isLoaded"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "hasDirtyAttributes", [compat], Object.getOwnPropertyDescriptor(_class.prototype, "hasDirtyAttributes"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "isSaving", [compat], Object.getOwnPropertyDescriptor(_class.prototype, "isSaving"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "isDeleted", [compat], Object.getOwnPropertyDescriptor(_class.prototype, "isDeleted"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "isNew", [compat], Object.getOwnPropertyDescriptor(_class.prototype, "isNew"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "isValid", [compat], Object.getOwnPropertyDescriptor(_class.prototype, "isValid"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "dirtyType", [compat], Object.getOwnPropertyDescriptor(_class.prototype, "dirtyType"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "isError", [compat], Object.getOwnPropertyDescriptor(_class.prototype, "isError"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "id", [tagged], Object.getOwnPropertyDescriptor(_class.prototype, "id"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "currentState", [tagged], Object.getOwnPropertyDescriptor(_class.prototype, "currentState"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "errors", [computeOnce], Object.getOwnPropertyDescriptor(_class.prototype, "errors"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "adapterError", [compat], Object.getOwnPropertyDescriptor(_class.prototype, "adapterError"), _class.prototype), _applyDecoratedDescriptor(_class, "inverseMap", [computeOnce], Object.getOwnPropertyDescriptor(_class, "inverseMap"), _class), _applyDecoratedDescriptor(_class, "relationships", [computeOnce], Object.getOwnPropertyDescriptor(_class, "relationships"), _class), _applyDecoratedDescriptor(_class, "relationshipNames", [computeOnce], Object.getOwnPropertyDescriptor(_class, "relationshipNames"), _class), _applyDecoratedDescriptor(_class, "relatedTypes", [computeOnce], Object.getOwnPropertyDescriptor(_class, "relatedTypes"), _class), _applyDecoratedDescriptor(_class, "relationshipsByName", [computeOnce], Object.getOwnPropertyDescriptor(_class, "relationshipsByName"), _class), _applyDecoratedDescriptor(_class, "relationshipsObject", [computeOnce], Object.getOwnPropertyDescriptor(_class, "relationshipsObject"), _class), _applyDecoratedDescriptor(_class, "fields", [computeOnce], Object.getOwnPropertyDescriptor(_class, "fields"), _class), _applyDecoratedDescriptor(_class, "attributes", [computeOnce], Object.getOwnPropertyDescriptor(_class, "attributes"), _class), _applyDecoratedDescriptor(_class, "transformedAttributes", [computeOnce], Object.getOwnPropertyDescriptor(_class, "transformedAttributes"), _class)), _class);
+}
+
+// @ts-expect-error TS doesn't know how to do `this` function overloads
 Model.prototype.save = save;
+// @ts-expect-error TS doesn't know how to do `this` function overloads
 Model.prototype.destroyRecord = destroyRecord;
 Model.prototype.unloadRecord = unloadRecord;
 Model.prototype.hasMany = hasMany;
@@ -4788,7 +5359,7 @@ defineSignal(Model.prototype, 'isReloading', false);
 // the values initialized during create to `setUnknownProperty`
 Model.prototype._createProps = null;
 Model.prototype._secretInit = null;
-if (macroCondition(getOwnConfig().env.DEBUG)) {
+if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
   const lookupDescriptor = function lookupDescriptor(obj, keyName) {
     let current = obj;
     do {
@@ -4833,4 +5404,4 @@ function isRelationshipSchema(meta) {
 function isAttributeSchema(meta) {
   return typeof meta === 'object' && meta !== null && 'kind' in meta && meta.kind === 'attribute';
 }
-export { Errors as E, LEGACY_SUPPORT as L, Model as M, PromiseBelongsTo as P, RelatedCollection as R, PromiseManyArray as a, save as b, reload as c, destroyRecord as d, deleteRecord as e, RecordState as f, changedAttributes as g, hasMany as h, belongsTo as i, createSnapshot as j, lookupLegacySupport as l, rollbackAttributes as r, serialize as s, unloadRecord as u };
+export { Errors as E, LEGACY_SUPPORT as L, Model as M, PromiseBelongsTo as P, RelatedCollection as R, PromiseManyArray as a, save as b, reload as c, destroyRecord as d, deleteRecord as e, RecordState as f, changedAttributes as g, hasMany as h, belongsTo as i, createSnapshot as j, isElementDescriptor as k, lookupLegacySupport as l, normalizeModelName as n, rollbackAttributes as r, serialize as s, unloadRecord as u };