@ember-data/model 5.4.0-beta.2 → 5.4.0-beta.20

package/{addon/model-YsOraZ6y.js → dist/model-rk3atPqV.js}

@@ -1,496 +1,120 @@
-import { assert, deprecate, warn } from '@ember/debug';
+import { deprecate } from '@ember/debug';
+import { dasherize } from '@ember-data/request-utils/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 { cached, compat } from '@ember-data/tracking';
-import { addToTransaction, defineSignal, getSignal, subscribe, peekSignal } from '@ember-data/tracking/-private';
+import { isStableIdentifier, recordIdentifierFor, storeFor, peekCache, SOURCE, fastPush, RelatedCollection, coerceId } from '@ember-data/store/-private';
+import { cached, compat, notifySignal } from '@ember-data/tracking';
+import { defineSignal, subscribed } 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 { EnableHydration } from '@warp-drive/core-types/request';
 import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
 import ObjectProxy from '@ember/object/proxy';
 import { cacheFor } from '@ember/object/internals';
-
-/**
-  @module @ember-data/store
-*/
-/**
-  A `ManyArray` is a `MutableArray` that represents the contents of a has-many
-  relationship.
-
-  The `ManyArray` is instantiated lazily the first time the relationship is
-  requested.
-
-  This class is not intended to be directly instantiated by consuming applications.
-
-  ### Inverses
-
-  Often, the relationships in Ember Data applications will have
-  an inverse. For example, imagine the following models are
-  defined:
-
-  ```app/models/post.js
-  import Model, { hasMany } from '@ember-data/model';
-
-  export default class PostModel extends Model {
-    @hasMany('comment') comments;
-  }
-  ```
-
-  ```app/models/comment.js
-  import Model, { belongsTo } from '@ember-data/model';
-
-  export default class CommentModel extends Model {
-    @belongsTo('post') post;
-  }
-  ```
-
-  If you created a new instance of `Post` and added
-  a `Comment` record to its `comments` has-many
-  relationship, you would expect the comment's `post`
-  property to be set to the post that contained
-  the has-many.
-
-  We call the record to which a relationship belongs-to the
-  relationship's _owner_.
-
-  @class ManyArray
-  @public
-*/
-class RelatedCollection extends RecordArray {
-  /**
-    The loading state of this array
-     @property {Boolean} isLoaded
-    @public
-    */
-
-  /**
-    `true` if the relationship is polymorphic, `false` otherwise.
-     @property {Boolean} isPolymorphic
-    @private
-    */
-
-  /**
-    Metadata associated with the request for async hasMany relationships.
-     Example
-     Given that the server returns the following JSON payload when fetching a
-    hasMany relationship:
-     ```js
-    {
-      "comments": [{
-        "id": 1,
-        "comment": "This is the first comment",
-      }, {
-    // ...
-      }],
-       "meta": {
-        "page": 1,
-        "total": 5
+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: '4.13',
+        enabled: '5.3'
       }
-    }
-    ```
-     You can then access the meta data via the `meta` property:
-     ```js
-    let comments = await post.comments;
-    let meta = comments.meta;
-     // meta.page => 1
-    // meta.total => 5
-    ```
-     @property {Object | null} meta
-    @public
-    */
-
-  /**
-     * Retrieve the links for this relationship
-     *
-     @property {Object | null} links
-     @public
-     */
-
-  // @ts-expect-error
-
-  constructor(options) {
-    super(options);
-    this.isLoaded = options.isLoaded || false;
-    this.isAsync = options.isAsync || false;
-    this.isPolymorphic = options.isPolymorphic || false;
-    this.identifier = options.identifier;
-    this.key = options.key;
-  }
-  [MUTATE](target, receiver, prop, args, _SIGNAL) {
-    switch (prop) {
-      case 'length 0':
-        {
-          Reflect.set(target, 'length', 0);
-          mutateReplaceRelatedRecords(this, [], _SIGNAL);
-          return true;
-        }
-      case 'replace cell':
-        {
-          const [index, prior, value] = args;
-          target[index] = value;
-          mutateReplaceRelatedRecord(this, {
-            value,
-            prior,
-            index
-          }, _SIGNAL);
-          return true;
-        }
-      case 'push':
-        {
-          const newValues = extractIdentifiersFromRecords(args);
-          assertNoDuplicates(this, target, currentState => currentState.push(...newValues), `Cannot push duplicates to a hasMany's state.`);
-          if (macroCondition(getOwnConfig().deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
-            // dedupe
-            const seen = new Set(target);
-            const unique = new Set();
-            args.forEach(item => {
-              const identifier = recordIdentifierFor(item);
-              if (!seen.has(identifier)) {
-                seen.add(identifier);
-                unique.add(item);
-              }
-            });
-            const newArgs = Array.from(unique);
-            const result = Reflect.apply(target[prop], receiver, newArgs);
-            if (newArgs.length) {
-              mutateAddToRelatedRecords(this, {
-                value: extractIdentifiersFromRecords(newArgs)
-              }, _SIGNAL);
-            }
-            return result;
-          }
-
-          // else, no dedupe, error on duplicates
-          const result = Reflect.apply(target[prop], receiver, args);
-          if (newValues.length) {
-            mutateAddToRelatedRecords(this, {
-              value: newValues
-            }, _SIGNAL);
-          }
-          return result;
-        }
-      case 'pop':
-        {
-          const result = Reflect.apply(target[prop], receiver, args);
-          if (result) {
-            mutateRemoveFromRelatedRecords(this, {
-              value: recordIdentifierFor(result)
-            }, _SIGNAL);
-          }
-          return result;
-        }
-      case 'unshift':
-        {
-          const newValues = extractIdentifiersFromRecords(args);
-          assertNoDuplicates(this, target, currentState => currentState.unshift(...newValues), `Cannot unshift duplicates to a hasMany's state.`);
-          if (macroCondition(getOwnConfig().deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
-            // dedupe
-            const seen = new Set(target);
-            const unique = new Set();
-            args.forEach(item => {
-              const identifier = recordIdentifierFor(item);
-              if (!seen.has(identifier)) {
-                seen.add(identifier);
-                unique.add(item);
-              }
-            });
-            const newArgs = Array.from(unique);
-            const result = Reflect.apply(target[prop], receiver, newArgs);
-            if (newArgs.length) {
-              mutateAddToRelatedRecords(this, {
-                value: extractIdentifiersFromRecords(newArgs),
-                index: 0
-              }, _SIGNAL);
-            }
-            return result;
-          }
-
-          // else, no dedupe, error on duplicates
-          const result = Reflect.apply(target[prop], receiver, args);
-          if (newValues.length) {
-            mutateAddToRelatedRecords(this, {
-              value: newValues,
-              index: 0
-            }, _SIGNAL);
-          }
-          return result;
-        }
-      case 'shift':
-        {
-          const result = Reflect.apply(target[prop], receiver, args);
-          if (result) {
-            mutateRemoveFromRelatedRecords(this, {
-              value: recordIdentifierFor(result),
-              index: 0
-            }, _SIGNAL);
-          }
-          return result;
-        }
-      case 'sort':
-        {
-          const result = Reflect.apply(target[prop], receiver, args);
-          mutateSortRelatedRecords(this, result.map(recordIdentifierFor), _SIGNAL);
-          return result;
-        }
-      case 'splice':
-        {
-          const [start, deleteCount, ...adds] = args;
-
-          // detect a full replace
-          if (start === 0 && deleteCount === this[SOURCE].length) {
-            const newValues = extractIdentifiersFromRecords(adds);
-            assertNoDuplicates(this, target, currentState => currentState.splice(start, deleteCount, ...newValues), `Cannot replace a hasMany's state with a new state that contains duplicates.`);
-            if (macroCondition(getOwnConfig().deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
-              // dedupe
-              const current = new Set(adds);
-              const unique = Array.from(current);
-              const newArgs = [start, deleteCount].concat(unique);
-              const result = Reflect.apply(target[prop], receiver, newArgs);
-              mutateReplaceRelatedRecords(this, extractIdentifiersFromRecords(unique), _SIGNAL);
-              return result;
-            }
-
-            // else, no dedupe, error on duplicates
-            const result = Reflect.apply(target[prop], receiver, args);
-            mutateReplaceRelatedRecords(this, newValues, _SIGNAL);
-            return result;
-          }
-          const newValues = extractIdentifiersFromRecords(adds);
-          assertNoDuplicates(this, target, currentState => currentState.splice(start, deleteCount, ...newValues), `Cannot splice a hasMany's state with a new state that contains duplicates.`);
-          if (macroCondition(getOwnConfig().deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
-            // dedupe
-            const currentState = target.slice();
-            currentState.splice(start, deleteCount);
-            const seen = new Set(currentState);
-            const unique = [];
-            adds.forEach(item => {
-              const identifier = recordIdentifierFor(item);
-              if (!seen.has(identifier)) {
-                seen.add(identifier);
-                unique.push(item);
-              }
-            });
-            const newArgs = [start, deleteCount, ...unique];
-            const result = Reflect.apply(target[prop], receiver, newArgs);
-            if (deleteCount > 0) {
-              mutateRemoveFromRelatedRecords(this, {
-                value: result.map(recordIdentifierFor),
-                index: start
-              }, _SIGNAL);
-            }
-            if (unique.length > 0) {
-              mutateAddToRelatedRecords(this, {
-                value: extractIdentifiersFromRecords(unique),
-                index: start
-              }, _SIGNAL);
-            }
-            return result;
-          }
-
-          // else, no dedupe, error on duplicates
-          const result = Reflect.apply(target[prop], receiver, args);
-          if (deleteCount > 0) {
-            mutateRemoveFromRelatedRecords(this, {
-              value: result.map(recordIdentifierFor),
-              index: start
-            }, _SIGNAL);
-          }
-          if (newValues.length > 0) {
-            mutateAddToRelatedRecords(this, {
-              value: newValues,
-              index: start
-            }, _SIGNAL);
-          }
-          return result;
-        }
-      default:
-        assert(`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);
-  }
-
-  /**
-    Reloads all of the records in the manyArray. If the manyArray
-    holds a relationship that was originally fetched using a links url
-    Ember Data will revisit the original links url to repopulate the
-    relationship.
-     If the manyArray holds the result of a `store.query()` reload will
-    re-run the original query.
-     Example
-     ```javascript
-    let user = store.peekRecord('user', '1')
-    await login(user);
-     let permissions = await user.permissions;
-    await permissions.reload();
-    ```
-     @method reload
-    @public
-  */
-  reload(options) {
-    // TODO this is odd, we don't ask the store for anything else like this?
-    return this._manager.reloadHasMany(this.key, options);
-  }
-
-  /**
-    Saves all of the records in the `ManyArray`.
-     Example
-     ```javascript
-    let inbox = await store.findRecord('inbox', '1');
-    let messages = await inbox.messages;
-    messages.forEach((message) => {
-      message.isRead = true;
     });
-    messages.save();
-    ```
-     @method save
-    @public
-    @return {PromiseArray} promise
-  */
-
-  /**
-    Create a child record within the owner
-     @method createRecord
-    @public
-    @param {Object} hash
-    @return {Model} record
-  */
-  createRecord(hash) {
-    const {
-      store
-    } = this;
-    assert(`Expected modelName to be set`, this.modelName);
-    const record = store.createRecord(this.modelName, hash);
-    this.push(record);
-    return record;
-  }
-  destroy() {
-    super.destroy(false);
+    return result;
   }
+  return type;
 }
-RelatedCollection.prototype.isAsync = false;
-RelatedCollection.prototype.isPolymorphic = false;
-RelatedCollection.prototype.identifier = null;
-RelatedCollection.prototype.cache = null;
-RelatedCollection.prototype._inverseIsAsync = false;
-RelatedCollection.prototype.key = '';
-RelatedCollection.prototype.DEPRECATED_CLASS_NAME = 'ManyArray';
-function assertRecordPassedToHasMany(record) {
-  assert(`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);
-}
-function extractIdentifierFromRecord$1(recordOrPromiseRecord) {
-  assertRecordPassedToHasMany(recordOrPromiseRecord);
-  return recordIdentifierFor(recordOrPromiseRecord);
+const PromiseObject = ObjectProxy.extend(PromiseProxyMixin);
+const 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 assertNoDuplicates(collection, target, callback, reason) {
-  const state = target.slice();
-  callback(state);
-  if (state.length !== new Set(state).size) {
-    const duplicates = state.filter((currentValue, currentIndex) => state.indexOf(currentValue) !== currentIndex);
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
-      deprecate(`${reason} This behavior is deprecated. Found duplicates for the following records within the new state provided to \`<${collection.identifier.type}:${collection.identifier.id || collection.identifier.lid}>.${collection.key}\`\n\t- ${Array.from(new Set(duplicates)).map(r => isStableIdentifier(r) ? r.lid : recordIdentifierFor(r).lid).sort((a, b) => a.localeCompare(b)).join('\n\t- ')}`, false, {
-        id: 'ember-data:deprecate-many-array-duplicates',
-        for: 'ember-data',
-        until: '6.0',
-        since: {
-          enabled: '5.3',
-          available: '5.3'
-        }
-      });
-    } else {
-      throw new Error(`${reason} Found duplicates for the following records within the new state provided to \`<${collection.identifier.type}:${collection.identifier.id || collection.identifier.lid}>.${collection.key}\`\n\t- ${Array.from(new Set(duplicates)).map(r => isStableIdentifier(r) ? r.lid : recordIdentifierFor(r).lid).sort((a, b) => a.localeCompare(b)).join('\n\t- ')}`);
+function findDeferredDecorator(target, prop) {
+  var _a;
+  let cursor = target.prototype;
+  while (cursor) {
+    let desc = (_a = deferred.get(cursor)) == null ? void 0 : _a.get(prop);
+    if (desc) {
+      return desc;
     }
+    cursor = cursor.prototype;
   }
 }
-function mutateAddToRelatedRecords(collection, operationInfo, _SIGNAL) {
-  mutate(collection, {
-    op: 'addToRelatedRecords',
-    record: collection.identifier,
-    field: collection.key,
-    ...operationInfo
-  }, _SIGNAL);
-}
-function mutateRemoveFromRelatedRecords(collection, operationInfo, _SIGNAL) {
-  mutate(collection, {
-    op: 'removeFromRelatedRecords',
-    record: collection.identifier,
-    field: collection.key,
-    ...operationInfo
-  }, _SIGNAL);
-}
-function mutateReplaceRelatedRecord(collection, operationInfo, _SIGNAL) {
-  mutate(collection, {
-    op: 'replaceRelatedRecord',
-    record: collection.identifier,
-    field: collection.key,
-    ...operationInfo
-  }, _SIGNAL);
-}
-function mutateReplaceRelatedRecords(collection, value, _SIGNAL) {
-  mutate(collection, {
-    op: 'replaceRelatedRecords',
-    record: collection.identifier,
-    field: collection.key,
-    value
-  }, _SIGNAL);
-}
-function mutateSortRelatedRecords(collection, value, _SIGNAL) {
-  mutate(collection, {
-    op: 'sortRelatedRecords',
-    record: collection.identifier,
-    field: collection.key,
-    value
-  }, _SIGNAL);
-}
-function mutate(collection, mutation, _SIGNAL) {
-  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];
-  });
-  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;
+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 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
+    });
+  }
+}
+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;
 
@@ -507,7 +131,7 @@ const Extended = PromiseObject;
   @extends PromiseObject
   @private
 */
-let PromiseBelongsTo = (_dec$1 = computed(), (_class$6 = class PromiseBelongsTo extends Extended {
+class PromiseBelongsTo extends Extended {
   get id() {
     const {
       key,
@@ -520,15 +144,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
@@ -536,8 +174,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
  */
@@ -557,14 +196,12 @@ var _class$5;
   @class PromiseManyArray
   @public
 */
-let PromiseManyArray = (_class$5 = class PromiseManyArray {
+class PromiseManyArray {
   constructor(promise, content) {
     this._update(promise, content);
     this.isDestroyed = false;
   }
 
-  //---- Methods/Properties on ArrayProxy that we will keep as our API
-
   /**
    * Retrieve the length of the content
    * @property length
@@ -573,7 +210,8 @@ 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)) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
       this['[]'];
     }
     return this.content ? this.content.length : 0;
@@ -589,6 +227,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);
@@ -603,7 +244,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;
   }
@@ -698,12 +343,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;
@@ -716,7 +366,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);
@@ -727,7 +378,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,
@@ -741,7 +392,7 @@ if (macroCondition(getOwnConfig().deprecations.DEPRECATE_COMPUTED_CHAINS)) {
   // requires that the tag `'[]'` be notified
   // on the ArrayProxy in order for `{{#each}}`
   // to recompute. We entangle the '[]' tag from content
-  // eslint-disable-next-line @typescript-eslint/no-floating-promises
+
   Object.defineProperty(PromiseManyArray.prototype, '[]', desc);
 }
 function tapPromise(proxy, promise) {
@@ -777,21 +428,29 @@ 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);
+      if (meta) {
+        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.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);
 }
@@ -823,24 +482,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;
@@ -876,8 +537,9 @@ let HasManyReference = (_class$4 = class HasManyReference {
    * @public
    */
   get identifiers() {
-    this._ref; // consume the tracked prop
-
+    ensureRefCanSubscribe(this);
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    this._ref;
     const resource = this._resource();
     const map = this.___relatedTokenMap;
     this.___relatedTokenMap = new Map();
@@ -904,6 +566,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);
@@ -1173,12 +838,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);
@@ -1252,10 +921,8 @@ let HasManyReference = (_class$4 = class HasManyReference {
    */
   value() {
     const support = LEGACY_SUPPORT.get(this.___identifier);
-    const loaded = this._isLoaded();
-    if (!loaded) {
-      // subscribe to changes
-      // for when we are not loaded yet
+    if (!ensureRefCanSubscribe(this)) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
       this._ref;
       return null;
     }
@@ -1368,13 +1035,32 @@ 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 ensureRefCanSubscribe(rel) {
+  const loaded = rel._isLoaded();
+  if (!loaded) {
+    // subscribe to changes
+    // for when we are not loaded yet
+    //
+    // because the graph optimizes the case where a relationship has never been subscribed,
+    // we force accessed to be true here. When we make the graph public we should create a
+    // subscribe/unsubscribe API
+    const edge = rel.graph.get(rel.___identifier, rel.key);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected a hasMany relationship for ${rel.___identifier.type}:${rel.key}`);
+      }
+    })('accessed' in edge) : {};
+    edge.accessed = true;
+    return false;
+  }
+  return true;
+}
 function isResourceIdentiferWithRelatedLinks(value) {
   return Boolean(value && value.links && value.links.related);
 }
@@ -1407,7 +1093,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.
    *
@@ -1510,6 +1196,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;
   }
@@ -1613,6 +1302,7 @@ let BelongsToReference = (_class$3 = class BelongsToReference {
     return meta;
   }
   _resource() {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
     this._ref; // subscribe
     const cache = this.store.cache;
     return cache.getRelationship(this.___identifier, this.key);
@@ -1737,7 +1427,7 @@ let BelongsToReference = (_class$3 = class BelongsToReference {
    @public
    @param {Object} doc a JSONAPI document object describing the new value of this relationship.
    @param {Boolean} [skipFetch] if `true`, do not attempt to fetch unloaded records
-   @return {Promise<RecordInstance | null | void>}
+   @return {Promise<OpaqueRecordInstance | null | void>}
   */
   async push(doc, skipFetch) {
     const {
@@ -1748,7 +1438,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);
       }
@@ -1929,15 +1619,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);
@@ -1950,7 +1648,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);
     }
@@ -1991,7 +1689,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;
@@ -2011,10 +1713,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,
@@ -2037,9 +1747,12 @@ class LegacySupport {
       if (relatedIdentifier === null) {
         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));
-        return toReturn;
+        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> })\`)`);
+          }
+        })(store._instanceCache.recordIsLoaded(relatedIdentifier, true)) : {};
+        return store._instanceCache.getRecord(relatedIdentifier);
       }
     }
   }
@@ -2060,7 +1773,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);
         }
@@ -2069,7 +1786,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;
@@ -2088,6 +1805,7 @@ class LegacySupport {
           isPolymorphic: definition.isPolymorphic,
           isAsync: definition.isAsync,
           _inverseIsAsync: definition.inverseIsAsync,
+          // @ts-expect-error Typescript doesn't have a way for us to thread the generic backwards so it infers unknown instead of T
           manager: this,
           isLoaded: !definition.isAsync,
           allowMutation: true
@@ -2096,10 +1814,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;
@@ -2114,10 +1836,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;
@@ -2138,10 +1864,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,
@@ -2158,11 +1888,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];
@@ -2172,7 +1910,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);
@@ -2184,7 +1926,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);
       }
@@ -2198,22 +1944,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;
@@ -2227,7 +1981,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;
       }
@@ -2236,7 +1990,7 @@ class LegacySupport {
         state
       } = relationship;
       upgradeStore(this.store);
-      const adapter = this.store.adapterFor(definition.type);
+      const adapter = this.store.adapterFor?.(definition.type);
       const {
         isStale,
         hasDematerializedInverse,
@@ -2246,13 +2000,18 @@ class LegacySupport {
       } = state;
       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 shouldFindViaLink = resource.links && resource.links.related && (typeof adapter?.findHasMany === 'function' || typeof identifiers === 'undefined') && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);
+      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,
@@ -2261,16 +2020,32 @@ 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));
-        return this.store.request({
+        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)) : {};
+        const req = field.options.linksMode ? {
+          url: getRelatedLink(resource),
+          op: 'findHasMany',
+          method: 'GET',
+          records: identifiers || [],
+          data: request,
+          [EnableHydration]: false
+        } : {
           op: 'findHasMany',
           records: identifiers || [],
           data: request,
           cacheOptions: {
             [Symbol.for('wd:skip-cache')]: true
           }
-        });
+        };
+        return this.store.request(req);
       }
       const preferLocalCache = hasReceivedData && !isEmpty;
       const hasLocalPartialData = hasDematerializedInverse || isEmpty && Array.isArray(identifiers) && identifiers.length > 0;
@@ -2280,8 +2055,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',
@@ -2297,7 +2080,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) {
@@ -2312,7 +2099,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,
@@ -2322,11 +2113,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,
@@ -2335,15 +2130,23 @@ class LegacySupport {
 
     // fetch via link
     if (shouldFindViaLink) {
-      const future = this.store.request({
+      const req = field.options.linksMode ? {
+        url: getRelatedLink(resource),
+        op: 'findBelongsTo',
+        method: 'GET',
+        records: identifier ? [identifier] : [],
+        data: request,
+        [EnableHydration]: false
+      } : {
         op: 'findBelongsTo',
         records: identifier ? [identifier] : [],
         data: request,
         cacheOptions: {
           [Symbol.for('wd:skip-cache')]: true
         }
-      });
-      this._pending[key] = future.then(doc => doc.content).finally(() => {
+      };
+      const future = this.store.request(req);
+      this._pending[key] = future.then(doc => field.options.linksMode ? doc.content.data : doc.content).finally(() => {
         this._pending[key] = undefined;
       });
       return this._pending[key];
@@ -2367,7 +2170,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',
@@ -2409,6 +2216,15 @@ class LegacySupport {
     this.isDestroyed = true;
   }
 }
+function getRelatedLink(resource) {
+  const related = resource.links?.related;
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected a related link`);
+    }
+  })(related) : {};
+  return typeof related === 'object' ? related.href : related;
+}
 function handleCompletedRelationshipRequest(recordExt, key, relationship, value, error) {
   delete recordExt._relationshipPromisesCache[key];
   relationship.state.shouldForceReload = false;
@@ -2455,7 +2271,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;
@@ -2469,7 +2289,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));
@@ -2477,26 +2301,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
@@ -2578,40 +2392,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}
@@ -2638,6 +2419,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);
@@ -2653,6 +2437,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}
@@ -2666,6 +2469,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) {
@@ -2673,6 +2479,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.
@@ -2831,9 +2657,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')) {
@@ -2851,17 +2675,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
@@ -2894,7 +2708,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',
@@ -2953,29 +2771,40 @@ function createSnapshot() {
     const FetchManager = importSync('@ember-data/legacy-compat/-private').FetchManager;
     store._fetchManager = new FetchManager(store);
   }
+
+  // @ts-expect-error Typescript isn't able to curry narrowed args that are divorced from each other.
   return store._fetchManager.createSnapshot(recordIdentifierFor$1(this));
 }
 function notifyChanges(identifier, value, key, record, store) {
-  if (value === 'attributes') {
-    if (key) {
-      notifyAttribute(store, identifier, key, record);
-    } else {
-      record.eachAttribute(name => {
-        notifyAttribute(store, identifier, name, record);
-      });
-    }
-  } 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);
-      notifyRelationship(identifier, key, record, meta);
-    } else {
-      record.eachRelationship((name, meta) => {
-        notifyRelationship(identifier, name, record, meta);
-      });
-    }
-  } else if (value === 'identity') {
-    record.notifyPropertyChange('id');
+  switch (value) {
+    case 'added':
+    case 'attributes':
+      if (key) {
+        notifyAttribute(store, identifier, key, record);
+      } else {
+        record.eachAttribute(name => {
+          notifyAttribute(store, identifier, name, record);
+        });
+      }
+      break;
+    case 'relationships':
+      if (key) {
+        const meta = record.constructor.relationshipsByName.get(key);
+        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) => {
+          notifyRelationship(identifier, name, record, meta);
+        });
+      }
+      break;
+    case 'identity':
+      record.notifyPropertyChange('id');
+      break;
   }
 }
 function notifyRelationship(identifier, key, record, meta) {
@@ -2996,8 +2825,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);
       }
@@ -3011,7 +2848,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';
@@ -3019,44 +2855,6 @@ function isInvalidError(error) {
   return !!error && error instanceof Error && 'isAdapterError' in error && error.isAdapterError === true && 'code' in error && error.code === 'InvalidError';
 }
 
-/**
- * A decorator that caches a getter while
- * providing the ability to bust that cache
- * when we so choose in a way that notifies
- * tracking systems.
- *
- * @internal
- */
-function tagged(_target, key, desc) {
-  // eslint-disable-next-line @typescript-eslint/unbound-method
-  const getter = desc.get;
-  // eslint-disable-next-line @typescript-eslint/unbound-method
-  const setter = desc.set;
-  desc.get = function () {
-    const signal = getSignal(this, key, true);
-    subscribe(signal);
-    if (signal.shouldReset) {
-      signal.shouldReset = false;
-      signal.lastValue = getter.call(this);
-    }
-    return signal.lastValue;
-  };
-  desc.set = function (v) {
-    getSignal(this, key, true); // ensure signal is setup in case we want to use it.
-    // probably notify here but not yet.
-    setter.call(this, v);
-  };
-  compat(desc);
-  return desc;
-}
-function notifySignal(obj, key) {
-  const signal = peekSignal(obj, key);
-  if (signal) {
-    signal.shouldReset = true;
-    addToTransaction(signal);
-  }
-}
-
 /**
 Historically EmberData managed a state machine
 for each record, the localState for which
@@ -3096,7 +2894,7 @@ root
 
   @internal
 */
-let RecordState = (_class$1 = class RecordState {
+class RecordState {
   constructor(record) {
     const store = storeFor$1(record);
     const identity = recordIdentifierFor(record);
@@ -3193,7 +2991,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++) {
@@ -3208,7 +3010,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);
         }
       }
@@ -3224,16 +3030,26 @@ let RecordState = (_class$1 = class RecordState {
   get isLoading() {
     return !this.isLoaded && this.pendingCount > 0 && this.fulfilledCount === 0;
   }
+  static {
+    decorateMethodV2(this.prototype, "isLoading", [subscribed]);
+  }
   get isLoaded() {
     if (this.isNew) {
       return true;
     }
     return this.fulfilledCount > 0 || !this.isEmpty;
   }
+  static {
+    decorateMethodV2(this.prototype, "isLoaded", [subscribed]);
+  }
   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) {
@@ -3241,26 +3057,53 @@ let RecordState = (_class$1 = class RecordState {
     }
     return true;
   }
+  static {
+    decorateMethodV2(this.prototype, "isSaved", [subscribed]);
+  }
   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", [subscribed]);
+  }
   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", [subscribed]);
+  }
   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", [subscribed]);
+  }
   get isValid() {
     return this.record.errors.length === 0;
   }
+  static {
+    decorateMethodV2(this.prototype, "isValid", [subscribed]);
+  }
   get isDirty() {
     const rd = this.cache;
     if (this.isEmpty || rd.isDeletionCommitted(this.identifier) || this.isDeleted && this.isNew) {
@@ -3268,6 +3111,9 @@ let RecordState = (_class$1 = class RecordState {
     }
     return this.isDeleted || this.isNew || rd.hasChangedAttrs(this.identifier);
   }
+  static {
+    decorateMethodV2(this.prototype, "isDirty", [subscribed]);
+  }
   get isError() {
     const errorReq = this._errorRequests[this._errorRequests.length - 1];
     if (!errorReq) {
@@ -3276,6 +3122,9 @@ let RecordState = (_class$1 = class RecordState {
       return true;
     }
   }
+  static {
+    decorateMethodV2(this.prototype, "isError", [subscribed]);
+  }
   get adapterError() {
     const request = this._lastError;
     if (!request) {
@@ -3283,9 +3132,15 @@ let RecordState = (_class$1 = class RecordState {
     }
     return request.state === 'rejected' && request.response.data;
   }
+  static {
+    decorateMethodV2(this.prototype, "adapterError", [subscribed]);
+  }
   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) {
@@ -3330,6 +3185,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) {
@@ -3352,38 +3210,20 @@ 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, _class2;
-function findPossibleInverses(type, inverseType, name, relationshipsSoFar) {
-  const possibleRelationships = relationshipsSoFar || [];
-  const relationshipMap = inverseType.relationships;
-  if (!relationshipMap) {
-    return possibleRelationships;
-  }
-  const relationshipsForType = relationshipMap.get(type.modelName);
-  const relationships = Array.isArray(relationshipsForType) ? relationshipsForType.filter(relationship => {
-    const optionsForRelationship = relationship.options;
-    if (!optionsForRelationship.inverse && optionsForRelationship.inverse !== null) {
-      return true;
-    }
-    return name === optionsForRelationship.inverse;
-  }) : null;
-  if (relationships) {
-    possibleRelationships.push.apply(possibleRelationships, relationships);
-  }
 
-  //Recurse to support polymorphism
-  if (type.superclass) {
-    findPossibleInverses(type.superclass, inverseType, name, possibleRelationships);
-  }
-  return possibleRelationships;
-}
+/**
+  @module @ember-data/model
+ */
 
 /*
  * This decorator allows us to lazily compute
@@ -3392,6 +3232,7 @@ function findPossibleInverses(type, inverseType, name, relationshipsSoFar) {
  */
 function computeOnce(target, propertyName, desc) {
   const cache = new WeakMap();
+  // eslint-disable-next-line @typescript-eslint/unbound-method
   const getter = desc.get;
   desc.get = function () {
     let meta = cache.get(this);
@@ -3430,14 +3271,13 @@ function computeOnce(target, propertyName, desc) {
   @public
   @extends Ember.EmberObject
 */
-let Model = (_class = (_class2 = class Model extends EmberObject {
-  constructor(...args) {
-    super(...args);
-    this.___private_notifications = void 0;
-  }
-  init(options = {}) {
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
-      if (!options._secretInit && !options._createProps) {
+
+class Model extends EmberObject {
+  // set during create by the store
+
+  init(options) {
+    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.');
       }
     }
@@ -3450,13 +3290,15 @@ let Model = (_class = (_class2 = 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) => {
       notifyChanges(identifier, type, field, this, store);
     });
   }
+
+  // @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();
@@ -3507,6 +3349,9 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     @type {Boolean}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "isEmpty", [compat]);
+  }
   get isLoading() {
     return this.currentState.isLoading;
   }
@@ -3520,15 +3365,17 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
      ```javascript
     let record = store.createRecord('model');
     record.isLoaded; // true
-     store.findRecord('model', 1).then(function(model) {
-      model.isLoaded; // true
-    });
+     const { content: { data: model } } = await store.request(findRecord({ type: 'model', id: '1' }));
+    model.isLoaded;
     ```
      @property isLoaded
     @public
     @type {Boolean}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "isLoading", [compat]);
+  }
   get isLoaded() {
     return this.currentState.isLoaded;
   }
@@ -3542,11 +3389,10 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
      ```javascript
     let record = store.createRecord('model');
     record.hasDirtyAttributes; // true
-     store.findRecord('model', 1).then(function(model) {
-      model.hasDirtyAttributes; // false
-      model.set('foo', 'some value');
-      model.hasDirtyAttributes; // true
-    });
+     const { content: { data: model } } = await store.request(findRecord({ type: 'model', id: '1' }));
+     model.hasDirtyAttributes; // false
+    model.foo = 'some value';
+    model.hasDirtyAttributes; // true
     ```
      @since 1.13.0
     @property hasDirtyAttributes
@@ -3554,6 +3400,9 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     @type {Boolean}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "isLoaded", [compat]);
+  }
   get hasDirtyAttributes() {
     return this.currentState.isDirty;
   }
@@ -3578,6 +3427,9 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     @type {Boolean}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "hasDirtyAttributes", [compat]);
+  }
   get isSaving() {
     return this.currentState.isSaving;
   }
@@ -3614,6 +3466,9 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     @type {Boolean}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "isSaving", [compat]);
+  }
   get isDeleted() {
     return this.currentState.isDeleted;
   }
@@ -3636,6 +3491,9 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     @type {Boolean}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "isDeleted", [compat]);
+  }
   get isNew() {
     return this.currentState.isNew;
   }
@@ -3649,6 +3507,9 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     @type {Boolean}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "isNew", [compat]);
+  }
   get isValid() {
     return this.currentState.isValid;
   }
@@ -3670,6 +3531,9 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     @type {String}
     @readOnly
   */
+  static {
+    decorateMethodV2(this.prototype, "isValid", [compat]);
+  }
   get dirtyType() {
     return this.currentState.dirtyType;
   }
@@ -3691,11 +3555,17 @@ let Model = (_class = (_class2 = 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`);
     }
   }
@@ -3723,9 +3593,8 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
      ```javascript
     let record = store.createRecord('model');
     record.id; // null
-     store.findRecord('model', 1).then(function(model) {
-      model.id; // '1'
-    });
+     const { content: { data: model } } = await store.request(findRecord({ type: 'model', id: '1' }));
+    model.id; // '1'
     ```
      @property id
     @public
@@ -3735,20 +3604,27 @@ let Model = (_class = (_class2 = 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 {
-        return void 0;
+        return null;
       }
     }
     return recordIdentifierFor$1(this).id;
   }
+  static {
+    decorateMethodV2(this.prototype, "id", [subscribed]);
+  }
   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');
@@ -3770,13 +3646,16 @@ let Model = (_class = (_class2 = 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", [subscribed]);
+  }
   set currentState(_v) {
     throw new Error('cannot set currentState');
   }
@@ -3846,9 +3725,15 @@ let Model = (_class = (_class2 = 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`);
   }
@@ -3865,7 +3750,6 @@ let Model = (_class = (_class2 = 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
@@ -3874,6 +3758,7 @@ let Model = (_class = (_class2 = 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, but Ember's types are forcing it
   notifyPropertyChange(prop) {
     notifySignal(this, prop);
     super.notifyPropertyChange(prop);
@@ -4061,7 +3946,11 @@ let Model = (_class = (_class2 = 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?');
+      }
+    })() : {};
   }
 
   /**
@@ -4178,7 +4067,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
   }
    ```
     @method eachRelationship
-    @public
+   @public
    @param {Function} callback the callback to invoke
    @param {any} binding the value to which the callback's `this` should be bound
    */
@@ -4194,6 +4083,45 @@ let Model = (_class = (_class2 = 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.
@@ -4226,12 +4154,20 @@ let Model = (_class = (_class2 = 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);
   }
 
@@ -4251,8 +4187,8 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     }
    ```
     ``` js
-   store.modelFor('post').inverseFor('comments', store) // { type: App.Message, name: 'owner', kind: 'belongsTo' }
-   store.modelFor('message').inverseFor('owner', store) // { type: App.Post, name: 'comments', kind: 'hasMany' }
+   store.modelFor('post').inverseFor('comments', store) // { type: 'message', name: 'owner', kind: 'belongsTo' }
+   store.modelFor('message').inverseFor('owner', store) // { type: 'post', name: 'comments', kind: 'hasMany' }
    ```
     @method inverseFor
     @public
@@ -4261,8 +4197,15 @@ let Model = (_class = (_class2 = 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];
@@ -4275,83 +4218,47 @@ let Model = (_class = (_class2 = 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);
+    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;
-    const isPolymorphic = options.polymorphic;
-
-    //If inverse is manually specified to be null, like  `comments: hasMany('message', { inverse: null })`
-    const isExplicitInverseNull = options.inverse === null;
-    const isAbstractType = !isExplicitInverseNull && isPolymorphic && !store.getSchemaDefinitionService().doesTypeExist(relationship.type);
-    if (isExplicitInverseNull || isAbstractType) {
-      assert(`No schema for the abstract type '${relationship.type}' for the polymorphic relationship '${name}' on '${this.modelName}' was provided by the SchemaDefinitionService.`, !isPolymorphic || isExplicitInverseNull);
-      return null;
-    }
-    let fieldOnInverse, inverseKind, inverseRelationship, inverseOptions;
-    const inverseSchema = this.typeForRelationship(name, store);
-
-    // if the type does not exist and we are not polymorphic
-    //If inverse is specified manually, return the inverse
-    if (options.inverse !== undefined) {
-      fieldOnInverse = options.inverse;
-      inverseRelationship = inverseSchema && inverseSchema.relationshipsByName.get(fieldOnInverse);
-      assert(`We found no field named '${fieldOnInverse}' on the schema for '${inverseSchema.modelName}' to be the inverse of the '${name}' relationship on '${this.modelName}'. This is most likely due to a missing field on your model definition.`, inverseRelationship);
-
-      // TODO probably just return the whole inverse here
-      inverseKind = inverseRelationship.kind;
-      inverseOptions = inverseRelationship.options;
-    } else {
-      //No inverse was specified manually, we need to use a heuristic to guess one
-      if (relationship.type === relationship.parentModelName) {
-        warn(`Detected a reflexive relationship named '${name}' on the schema for '${relationship.type}' without an inverse option. Look at https://guides.emberjs.com/current/models/relationships/#toc_reflexive-relations for how to explicitly specify inverses.`, false, {
-          id: 'ds.model.reflexive-relationship-without-inverse'
-        });
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected the relationship ${name} on ${this.modelName} to define an inverse.`);
       }
-      let possibleRelationships = findPossibleInverses(this, inverseSchema, name);
-      if (possibleRelationships.length === 0) {
-        return null;
-      }
-      if (macroCondition(getOwnConfig().env.DEBUG)) {
-        const filteredRelationships = possibleRelationships.filter(possibleRelationship => {
-          const optionsForRelationship = possibleRelationship.options;
-          return name === optionsForRelationship.inverse;
-        });
-        assert("You defined the '" + name + "' relationship on " + this + ', but you defined the inverse relationships of type ' + inverseSchema.toString() + ' multiple times. Look at https://guides.emberjs.com/current/models/relationships/#toc_explicit-inverses for how to explicitly specify inverses', filteredRelationships.length < 2);
-      }
-      const explicitRelationship = possibleRelationships.find(relationship => relationship.options.inverse === name);
-      if (explicitRelationship) {
-        possibleRelationships = [explicitRelationship];
-      }
-      assert("You defined the '" + name + "' relationship on " + this + ', but multiple possible inverse relationships of type ' + this + ' were found on ' + inverseSchema + '. Look at https://guides.emberjs.com/current/models/relationships/#toc_explicit-inverses for how to explicitly specify inverses', possibleRelationships.length === 1);
-      fieldOnInverse = possibleRelationships[0].name;
-      inverseKind = possibleRelationships[0].kind;
-      inverseOptions = possibleRelationships[0].options;
+    })(options.inverse === null || typeof options.inverse === 'string' && options.inverse.length > 0) : {};
+    if (options.inverse === null) {
+      return null;
     }
-
-    // ensure inverse is properly configured
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
-      if (isPolymorphic) {
-        assert(`Relationships that satisfy polymorphic relationships MUST define which abstract-type they are satisfying using 'as'. The field '${fieldOnInverse}' on type '${inverseSchema.modelName}' is misconfigured.`, inverseOptions.as);
-        assert(`options.as should match the expected type of the polymorphic relationship. Expected field '${fieldOnInverse}' on type '${inverseSchema.modelName}' to specify '${relationship.type}' but found '${inverseOptions.as}'`, !!inverseOptions.as && relationship.type === inverseOptions.as);
+    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;
     }
-
-    // ensure we are properly configured
-    if (macroCondition(getOwnConfig().env.DEBUG)) {
-      if (inverseOptions.polymorphic) {
-        assert(`Relationships that satisfy polymorphic relationships MUST define which abstract-type they are satisfying using 'as'. The field '${name}' on type '${this.modelName}' is misconfigured.`, options.as);
-        assert(`options.as should match the expected type of the polymorphic relationship. Expected field '${name}' on type '${this.modelName}' to specify '${inverseRelationship.type}' but found '${options.as}'`, !!options.as && inverseRelationship.type === options.as);
+    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}'`);
       }
-    }
-    assert(`The ${inverseSchema.modelName}:${fieldOnInverse} relationship declares 'inverse: null', but it was resolved as the inverse for ${this.modelName}:${name}.`, inverseOptions.inverse !== null);
-    return {
-      type: inverseSchema,
-      name: fieldOnInverse,
-      kind: inverseKind,
-      options: inverseOptions
-    };
+    })(inverseField && (inverseField.kind === 'belongsTo' || inverseField.kind === 'hasMany')) : {};
+    return inverseField || null;
   }
 
   /**
@@ -4389,7 +4296,11 @@ let Model = (_class = (_class2 = 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;
 
@@ -4433,14 +4344,21 @@ let Model = (_class = (_class2 = 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: []
     };
     this.eachComputedProperty((name, meta) => {
-      if (meta.kind === 'hasMany' || meta.kind === 'belongsTo') {
+      if (isRelationshipSchema(meta)) {
         names[meta.kind].push(name);
       }
     });
@@ -4472,8 +4390,15 @@ let Model = (_class = (_class2 = 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);
@@ -4484,7 +4409,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
       const name = relationships[i];
       const meta = rels[name];
       const modelName = meta.type;
-      if (types.indexOf(modelName) === -1) {
+      if (!types.includes(modelName)) {
         types.push(modelName);
       }
     }
@@ -4519,8 +4444,15 @@ let Model = (_class = (_class2 = 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);
@@ -4531,19 +4463,35 @@ let Model = (_class = (_class2 = 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) => {
-      if (meta.kind === 'hasMany' || meta.kind === 'belongsTo') {
-        // TODO deprecate key being here
-        meta.key = name;
-        meta.name = name;
-        meta.parentModelName = modelName;
-        relationships[name] = meta;
-        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 > 0));
+      if (!isRelationshipSchema(meta)) {
+        return;
       }
+      // TODO deprecate key being here
+      meta.key = name;
+      meta.name = name;
+      relationships[name] = meta;
+      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;
   }
@@ -4580,13 +4528,20 @@ let Model = (_class = (_class2 = 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 (meta.kind === 'hasMany' || meta.kind === 'belongsTo') {
+      if (isRelationshipSchema(meta)) {
         map.set(name, meta.kind);
-      } else if (meta.kind === 'attribute') {
+      } else if (isAttributeSchema(meta)) {
         map.set(name, 'attribute');
       }
     });
@@ -4603,8 +4558,15 @@ let Model = (_class = (_class2 = 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);
     });
@@ -4622,15 +4584,30 @@ let Model = (_class = (_class2 = 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];
       callback.call(binding, type);
     }
   }
+
+  /**
+   *
+   * @method determineRelationshipType
+   * @private
+   * @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);
@@ -4680,11 +4657,19 @@ let Model = (_class = (_class2 = 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 (meta.kind === 'attribute') {
-        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');
+      if (isAttributeSchema(meta)) {
+        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;
@@ -4725,8 +4710,15 @@ let Model = (_class = (_class2 = 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) {
@@ -4770,8 +4762,15 @@ let Model = (_class = (_class2 = 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);
     });
@@ -4813,7 +4812,11 @@ let Model = (_class = (_class2 = 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);
     });
@@ -4826,11 +4829,18 @@ let Model = (_class = (_class2 = 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}`;
   }
-}, _class2.isModel = true, _class2.modelName = null, _class2), (_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;
@@ -4847,64 +4857,7 @@ defineSignal(Model.prototype, 'isReloading', false);
 // the values initialized during create to `setUnknownProperty`
 Model.prototype._createProps = null;
 Model.prototype._secretInit = null;
-if (macroCondition(getOwnConfig().includeDataAdapter)) {
-  /**
-   Provides info about the model for debugging purposes
-   by grouping the properties into more semantic groups.
-    Meant to be used by debugging tools such as the Chrome Ember Extension.
-    - Groups all attributes in "Attributes" group.
-   - Groups all belongsTo relationships in "Belongs To" group.
-   - Groups all hasMany relationships in "Has Many" group.
-   - Groups all flags in "Flags" group.
-   - Flags relationship CPs as expensive properties.
-    @method _debugInfo
-   @for Model
-   @private
-   */
-  Model.prototype._debugInfo = function () {
-    const relationships = {};
-    const expensiveProperties = [];
-    const identifier = recordIdentifierFor$1(this);
-    const schema = this.store.getSchemaDefinitionService();
-    const attrDefs = schema.attributesDefinitionFor(identifier);
-    const relDefs = schema.relationshipsDefinitionFor(identifier);
-    const attributes = Object.keys(attrDefs);
-    attributes.unshift('id');
-    const groups = [{
-      name: 'Attributes',
-      properties: attributes,
-      expand: true
-    }];
-    Object.keys(relDefs).forEach(name => {
-      const relationship = relDefs[name];
-      let properties = relationships[relationship.kind];
-      if (properties === undefined) {
-        properties = relationships[relationship.kind] = [];
-        groups.push({
-          name: relationship.kind,
-          properties,
-          expand: true
-        });
-      }
-      properties.push(name);
-      expensiveProperties.push(name);
-    });
-    groups.push({
-      name: 'Flags',
-      properties: ['isLoaded', 'hasDirtyAttributes', 'isSaving', 'isDeleted', 'isError', 'isNew', 'isValid']
-    });
-    return {
-      propertyInfo: {
-        // include all other mixins / properties (not just the grouped ones)
-        includeOtherProperties: true,
-        groups: groups,
-        // don't pre-calculate unless cached
-        expensiveProperties: expensiveProperties
-      }
-    };
-  };
-}
-if (macroCondition(getOwnConfig().env.DEBUG)) {
+if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
   const lookupDescriptor = function lookupDescriptor(obj, keyName) {
     let current = obj;
     do {
@@ -4916,27 +4869,37 @@ if (macroCondition(getOwnConfig().env.DEBUG)) {
     } while (current !== null);
     return null;
   };
-  Model.reopen({
-    init() {
-      this._super(...arguments);
-      const ourDescriptor = lookupDescriptor(Model.prototype, 'currentState');
-      const theirDescriptor = lookupDescriptor(this, 'currentState');
-      const realState = this.___recordState;
-      if (ourDescriptor.get !== theirDescriptor.get || realState !== this.currentState) {
-        throw new Error(`'currentState' is a reserved property name on instances of classes extending Model. Please choose a different property name for ${this.constructor.toString()}`);
-      }
-      const ID_DESCRIPTOR = lookupDescriptor(Model.prototype, 'id');
-      const idDesc = lookupDescriptor(this, 'id');
-      if (idDesc.get !== ID_DESCRIPTOR.get) {
-        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.constructor.toString()}`);
-      }
+
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  const init = Model.prototype.init;
+  Model.prototype.init = function (createArgs) {
+    init.call(this, createArgs);
+    const ourDescriptor = lookupDescriptor(Model.prototype, 'currentState');
+    const theirDescriptor = lookupDescriptor(this, 'currentState');
+    if (!ourDescriptor || !theirDescriptor) {
+      throw new Error(`Unable to determine if 'currentState' is a reserved property name on instances of classes extending Model. Please ensure that 'currentState' is not defined as a property on ${this.constructor.toString()}`);
+    }
+    const realState = this.___recordState;
+    if (ourDescriptor.get !== theirDescriptor.get || realState !== this.currentState) {
+      throw new Error(`'currentState' is a reserved property name on instances of classes extending Model. Please choose a different property name for ${this.constructor.toString()}`);
+    }
+    const ID_DESCRIPTOR = lookupDescriptor(Model.prototype, 'id');
+    const idDesc = lookupDescriptor(this, 'id');
+    if (!ID_DESCRIPTOR || !idDesc) {
+      throw new Error(`Unable to determine if 'id' is a reserved property name on instances of classes extending Model. Please ensure that 'id' is not defined as a property on ${this.constructor.toString()}`);
+    }
+    if (idDesc.get !== ID_DESCRIPTOR.get) {
+      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.constructor.toString()}`);
     }
-  });
-  Model.reopen = function deprecatedReopen() {
-    assert(`Model.reopen is deprecated. Use Foo extends Model to extend your class instead.`);
-  };
-  Model.reopenClass = function deprecatedReopenClass() {
-    assert(`Model.reopenClass is deprecated. Use Foo extends Model to add static methods and properties to your class instead.`);
   };
+  delete Model.reopen;
+  delete Model.reopenClass;
+}
+function isRelationshipSchema(meta) {
+  const hasKind = typeof meta === 'object' && meta !== null && 'kind' in meta && 'options' in meta;
+  return hasKind && (meta.kind === 'hasMany' || meta.kind === 'belongsTo');
+}
+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, RecordState as R, PromiseManyArray as a, save as b, reload as c, destroyRecord as d, deleteRecord as e, changedAttributes as f, belongsTo as g, hasMany as h, createSnapshot as i, isElementDescriptor as j, lookupLegacySupport as l, normalizeModelName as n, rollbackAttributes as r, serialize as s, unloadRecord as u };