@ember-data/model 5.4.0-beta.9 → 5.4.1-beta.0

package/dist/{model-BFnMMaye.js → model-rk3atPqV.js}

@@ -3,15 +3,16 @@ 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 { LiveArray, MUTATE, SOURCE, recordIdentifierFor, ARRAY_SIGNAL, notifyArray, isStableIdentifier, storeFor, peekCache, fastPush, coerceId } from '@ember-data/store/-private';
-import { cached, compat } from '@ember-data/tracking';
-import { addToTransaction, defineSignal, peekSignal, getSignal, subscribe } 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 { 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';
@@ -38,7 +39,7 @@ function normalizeModelName(type) {
       until: '6.0',
       for: 'ember-data',
       since: {
-        available: '5.3',
+        available: '4.13',
         enabled: '5.3'
       }
     });
@@ -46,487 +47,8 @@ function normalizeModelName(type) {
   }
   return type;
 }
-
-/**
-  @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 LiveArray {
-  /**
-    The loading state of this array
-     @property {Boolean} isLoaded
-    @public
-    */
-
-  /**
-    `true` if the relationship is polymorphic, `false` otherwise.
-     @property {Boolean} isPolymorphic
-    @private
-    */
-
-  /**
-    Metadata associated with the request for async hasMany relationships.
-     Example
-     Given that the server returns the following JSON payload when fetching a
-    hasMany relationship:
-     ```js
-    {
-      "comments": [{
-        "id": 1,
-        "comment": "This is the first comment",
-      }, {
-    // ...
-      }],
-       "meta": {
-        "page": 1,
-        "total": 5
-      }
-    }
-    ```
-     You can then access the meta data via the `meta` property:
-     ```js
-    let comments = await post.comments;
-    let meta = comments.meta;
-     // meta.page => 1
-    // meta.total => 5
-    ```
-     @property {Object | null} meta
-    @public
-    */
-
-  /**
-     * Retrieve the links for this relationship
-     *
-     @property {Object | null} links
-     @public
-     */
-
-  constructor(options) {
-    super(options);
-    this.isLoaded = options.isLoaded || false;
-    this.isAsync = options.isAsync || false;
-    this.isPolymorphic = options.isPolymorphic || false;
-    this.identifier = options.identifier;
-    this.key = options.key;
-  }
-  [MUTATE](target, receiver, prop, args, _SIGNAL) {
-    switch (prop) {
-      case 'length 0':
-        {
-          Reflect.set(target, 'length', 0);
-          mutateReplaceRelatedRecords(this, [], _SIGNAL);
-          return true;
-        }
-      case 'replace cell':
-        {
-          const [index, prior, value] = args;
-          target[index] = value;
-          mutateReplaceRelatedRecord(this, {
-            value,
-            prior,
-            index
-          }, _SIGNAL);
-          return true;
-        }
-      case 'push':
-        {
-          const newValues = extractIdentifiersFromRecords(args);
-          assertNoDuplicates(this, target, currentState => currentState.push(...newValues), `Cannot push duplicates to a hasMany's state.`);
-          if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
-            // dedupe
-            const seen = new Set(target);
-            const unique = new Set();
-            args.forEach(item => {
-              const identifier = recordIdentifierFor(item);
-              if (!seen.has(identifier)) {
-                seen.add(identifier);
-                unique.add(item);
-              }
-            });
-            const newArgs = Array.from(unique);
-            const result = Reflect.apply(target[prop], receiver, newArgs);
-            if (newArgs.length) {
-              mutateAddToRelatedRecords(this, {
-                value: extractIdentifiersFromRecords(newArgs)
-              }, _SIGNAL);
-            }
-            return result;
-          }
-
-          // else, no dedupe, error on duplicates
-          const result = Reflect.apply(target[prop], receiver, args);
-          if (newValues.length) {
-            mutateAddToRelatedRecords(this, {
-              value: newValues
-            }, _SIGNAL);
-          }
-          return result;
-        }
-      case 'pop':
-        {
-          const result = Reflect.apply(target[prop], receiver, args);
-          if (result) {
-            mutateRemoveFromRelatedRecords(this, {
-              value: recordIdentifierFor(result)
-            }, _SIGNAL);
-          }
-          return result;
-        }
-      case 'unshift':
-        {
-          const newValues = extractIdentifiersFromRecords(args);
-          assertNoDuplicates(this, target, currentState => currentState.unshift(...newValues), `Cannot unshift duplicates to a hasMany's state.`);
-          if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
-            // dedupe
-            const seen = new Set(target);
-            const unique = new Set();
-            args.forEach(item => {
-              const identifier = recordIdentifierFor(item);
-              if (!seen.has(identifier)) {
-                seen.add(identifier);
-                unique.add(item);
-              }
-            });
-            const newArgs = Array.from(unique);
-            const result = Reflect.apply(target[prop], receiver, newArgs);
-            if (newArgs.length) {
-              mutateAddToRelatedRecords(this, {
-                value: extractIdentifiersFromRecords(newArgs),
-                index: 0
-              }, _SIGNAL);
-            }
-            return result;
-          }
-
-          // else, no dedupe, error on duplicates
-          const result = Reflect.apply(target[prop], receiver, args);
-          if (newValues.length) {
-            mutateAddToRelatedRecords(this, {
-              value: newValues,
-              index: 0
-            }, _SIGNAL);
-          }
-          return result;
-        }
-      case 'shift':
-        {
-          const result = Reflect.apply(target[prop], receiver, args);
-          if (result) {
-            mutateRemoveFromRelatedRecords(this, {
-              value: recordIdentifierFor(result),
-              index: 0
-            }, _SIGNAL);
-          }
-          return result;
-        }
-      case 'sort':
-        {
-          const result = Reflect.apply(target[prop], receiver, args);
-          mutateSortRelatedRecords(this, result.map(recordIdentifierFor), _SIGNAL);
-          return result;
-        }
-      case 'splice':
-        {
-          const [start, deleteCount, ...adds] = args;
-
-          // detect a full replace
-          if (start === 0 && deleteCount === this[SOURCE].length) {
-            const newValues = extractIdentifiersFromRecords(adds);
-            assertNoDuplicates(this, target, currentState => currentState.splice(start, deleteCount, ...newValues), `Cannot replace a hasMany's state with a new state that contains duplicates.`);
-            if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
-              // dedupe
-              const current = new Set(adds);
-              const unique = Array.from(current);
-              const newArgs = [start, deleteCount].concat(unique);
-              const result = Reflect.apply(target[prop], receiver, newArgs);
-              mutateReplaceRelatedRecords(this, extractIdentifiersFromRecords(unique), _SIGNAL);
-              return result;
-            }
-
-            // else, no dedupe, error on duplicates
-            const result = Reflect.apply(target[prop], receiver, args);
-            mutateReplaceRelatedRecords(this, newValues, _SIGNAL);
-            return result;
-          }
-          const newValues = extractIdentifiersFromRecords(adds);
-          assertNoDuplicates(this, target, currentState => currentState.splice(start, deleteCount, ...newValues), `Cannot splice a hasMany's state with a new state that contains duplicates.`);
-          if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
-            // dedupe
-            const currentState = target.slice();
-            currentState.splice(start, deleteCount);
-            const seen = new Set(currentState);
-            const unique = [];
-            adds.forEach(item => {
-              const identifier = recordIdentifierFor(item);
-              if (!seen.has(identifier)) {
-                seen.add(identifier);
-                unique.push(item);
-              }
-            });
-            const newArgs = [start, deleteCount, ...unique];
-            const result = Reflect.apply(target[prop], receiver, newArgs);
-            if (deleteCount > 0) {
-              mutateRemoveFromRelatedRecords(this, {
-                value: result.map(recordIdentifierFor),
-                index: start
-              }, _SIGNAL);
-            }
-            if (unique.length > 0) {
-              mutateAddToRelatedRecords(this, {
-                value: extractIdentifiersFromRecords(unique),
-                index: start
-              }, _SIGNAL);
-            }
-            return result;
-          }
-
-          // else, no dedupe, error on duplicates
-          const result = Reflect.apply(target[prop], receiver, args);
-          if (deleteCount > 0) {
-            mutateRemoveFromRelatedRecords(this, {
-              value: result.map(recordIdentifierFor),
-              index: start
-            }, _SIGNAL);
-          }
-          if (newValues.length > 0) {
-            mutateAddToRelatedRecords(this, {
-              value: newValues,
-              index: start
-            }, _SIGNAL);
-          }
-          return result;
-        }
-      default:
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          {
-            throw new Error(`unable to convert ${prop} into a transaction that updates the cache state for this record array`);
-          }
-        })() : {};
-    }
-  }
-  notify() {
-    const signal = this[ARRAY_SIGNAL];
-    signal.shouldReset = true;
-    notifyArray(this);
-  }
-
-  /**
-    Reloads all of the records in the manyArray. If the manyArray
-    holds a relationship that was originally fetched using a links url
-    EmberData will revisit the original links url to repopulate the
-    relationship.
-     If the ManyArray holds the result of a `store.query()` reload will
-    re-run the original query.
-     Example
-     ```javascript
-    let user = store.peekRecord('user', '1')
-    await login(user);
-     let permissions = await user.permissions;
-    await permissions.reload();
-    ```
-     @method reload
-    @public
-  */
-  reload(options) {
-    // 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;
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected modelName to be set`);
-      }
-    })(this.modelName) : {};
-    const record = store.createRecord(this.modelName, hash);
-    this.push(record);
-    return record;
-  }
-  destroy() {
-    super.destroy(false);
-  }
-}
-RelatedCollection.prototype.isAsync = false;
-RelatedCollection.prototype.isPolymorphic = false;
-RelatedCollection.prototype.identifier = null;
-RelatedCollection.prototype.cache = null;
-RelatedCollection.prototype._inverseIsAsync = false;
-RelatedCollection.prototype.key = '';
-RelatedCollection.prototype.DEPRECATED_CLASS_NAME = 'ManyArray';
-function assertRecordPassedToHasMany(record) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`All elements of a hasMany relationship must be instances of Model, you passed $${typeof record}`);
-    }
-  })(function () {
-    try {
-      recordIdentifierFor(record);
-      return true;
-    } catch {
-      return false;
-    }
-  }()) : {};
-}
-function extractIdentifiersFromRecords(records) {
-  return records.map(extractIdentifierFromRecord$1);
-}
-function extractIdentifierFromRecord$1(recordOrPromiseRecord) {
-  assertRecordPassedToHasMany(recordOrPromiseRecord);
-  return recordIdentifierFor(recordOrPromiseRecord);
-}
-function assertNoDuplicates(collection, target, callback, reason) {
-  const state = target.slice();
-  callback(state);
-  if (state.length !== new Set(state).size) {
-    const duplicates = state.filter((currentValue, currentIndex) => state.indexOf(currentValue) !== currentIndex);
-    if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
-      deprecate(`${reason} This behavior is deprecated. Found duplicates for the following records within the new state provided to \`<${collection.identifier.type}:${collection.identifier.id || collection.identifier.lid}>.${collection.key}\`\n\t- ${Array.from(new Set(duplicates)).map(r => isStableIdentifier(r) ? r.lid : recordIdentifierFor(r).lid).sort((a, b) => a.localeCompare(b)).join('\n\t- ')}`, false, {
-        id: 'ember-data:deprecate-many-array-duplicates',
-        for: 'ember-data',
-        until: '6.0',
-        since: {
-          enabled: '5.3',
-          available: '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 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);
-}
 const PromiseObject = ObjectProxy.extend(PromiseProxyMixin);
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all) __defProp(target, name, {
-    get: all[name],
-    enumerable: true
-  });
-};
-
-// src/runtime.ts
-var runtime_exports = {};
-__export(runtime_exports, {
-  c: () => decorateClass,
-  f: () => decorateFieldV1,
-  g: () => decorateFieldV2,
-  i: () => initializeDeferredDecorator,
-  m: () => decorateMethodV1,
-  n: () => decorateMethodV2,
-  p: () => decoratePOJO
-});
-var deferred = /* @__PURE__ */new WeakMap();
+const deferred = /* @__PURE__ */new WeakMap();
 function deferDecorator(proto, prop, desc) {
   let map = deferred.get(proto);
   if (!map) {
@@ -536,18 +58,16 @@ function deferDecorator(proto, prop, desc) {
   map.set(prop, desc);
 }
 function findDeferredDecorator(target, prop) {
+  var _a;
   let cursor = target.prototype;
   while (cursor) {
-    let desc = deferred.get(cursor)?.get(prop);
+    let desc = (_a = deferred.get(cursor)) == null ? void 0 : _a.get(prop);
     if (desc) {
       return desc;
     }
     cursor = cursor.prototype;
   }
 }
-function decorateFieldV1(target, prop, decorators, initializer) {
-  return decorateFieldV2(target.prototype, prop, decorators, initializer);
-}
 function decorateFieldV2(prototype, prop, decorators, initializer) {
   let desc = {
     configurable: true,
@@ -567,11 +87,6 @@ function decorateFieldV2(prototype, prop, decorators, initializer) {
     deferDecorator(prototype, prop, desc);
   }
 }
-function decorateMethodV1({
-  prototype
-}, prop, decorators) {
-  return decorateMethodV2(prototype, prop, decorators);
-}
 function decorateMethodV2(prototype, prop, decorators) {
   const origDesc = Object.getOwnPropertyDescriptor(prototype, prop);
   let desc = {
@@ -597,35 +112,6 @@ function initializeDeferredDecorator(target, prop) {
     });
   }
 }
-function decorateClass(target, decorators) {
-  return decorators.reduce((accum, decorator) => decorator(accum) || accum, target);
-}
-function decoratePOJO(pojo, decorated) {
-  for (let [type, prop, decorators] of decorated) {
-    if (type === "field") {
-      decoratePojoField(pojo, prop, decorators);
-    } else {
-      decorateMethodV2(pojo, prop, decorators);
-    }
-  }
-  return pojo;
-}
-function decoratePojoField(pojo, prop, decorators) {
-  let desc = {
-    configurable: true,
-    enumerable: true,
-    writable: true,
-    initializer: () => Object.getOwnPropertyDescriptor(pojo, prop)?.value
-  };
-  for (let decorator of decorators) {
-    desc = decorator(pojo, prop, desc) || desc;
-  }
-  if (desc.initializer) {
-    desc.value = desc.initializer.call(pojo);
-    delete desc.initializer;
-  }
-  Object.defineProperty(pojo, prop, desc);
-}
 const LegacyPromiseProxy = Symbol.for('LegacyPromiseProxy');
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-extraneous-class
@@ -725,6 +211,7 @@ class PromiseManyArray {
     // shouldn't be needed, but ends up being needed
     // for computed chains even in 4.x
     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;
@@ -905,7 +392,7 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_COMPUTED_C
   // 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) {
@@ -949,16 +436,18 @@ if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
     }
     if (parentDefinition.isPolymorphic) {
       const meta = store.schema.fields(addedIdentifier)?.get(parentDefinition.inverseKey);
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-        if (!test) {
-          throw new Error(`Expected the schema for the field ${parentDefinition.inverseKey} on ${addedIdentifier.type} to be for a legacy relationship`);
-        }
-      })(!meta || meta.kind === 'belongsTo' || meta.kind === 'hasMany') : {};
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-        if (!test) {
-          throw new Error(`The schema for the relationship '${parentDefinition.inverseKey}' on '${addedIdentifier.type}' type does not implement '${parentDefinition.type}' and thus cannot be assigned to the '${parentDefinition.key}' relationship in '${parentIdentifier.type}'. The definition should specify 'as: "${parentDefinition.type}"' in options.`);
-        }
-      })(meta?.options.as === parentDefinition.type) : {};
+      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) : {};
+      }
     }
   };
 }
@@ -1048,8 +537,9 @@ 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();
@@ -1431,10 +921,8 @@ 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;
     }
@@ -1553,6 +1041,26 @@ function isMaybeResource(object) {
   const keys = Object.keys(object).filter(k => k !== 'id' && k !== 'type' && k !== 'lid');
   return keys.length > 0;
 }
+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);
 }
@@ -1794,6 +1302,7 @@ 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);
@@ -2238,13 +1747,12 @@ class LegacySupport {
       if (relatedIdentifier === null) {
         return null;
       } else {
-        const toReturn = store._instanceCache.getRecord(relatedIdentifier);
         macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
           if (!test) {
             throw new Error(`You looked up the '${key}' relationship on a '${identifier.type}' with id ${identifier.id || 'null'} but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (\`belongsTo(<type>, { async: true, inverse: <inverse> })\`)`);
           }
-        })(toReturn === null || store._instanceCache.recordIsLoaded(relatedIdentifier, true)) : {};
-        return toReturn;
+        })(store._instanceCache.recordIsLoaded(relatedIdentifier, true)) : {};
+        return store._instanceCache.getRecord(relatedIdentifier);
       }
     }
   }
@@ -2297,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
@@ -2521,14 +2030,22 @@ class LegacySupport {
             throw new Error(`Expected stable identifiers`);
           }
         })(!identifiers || identifiers.every(isStableIdentifier)) : {};
-        return this.store.request({
+        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;
@@ -2613,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];
@@ -2691,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;
@@ -3242,30 +2776,35 @@ function createSnapshot() {
   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);
-      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);
-      });
-    }
-  } 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) {
@@ -3316,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
@@ -3530,7 +3031,7 @@ class RecordState {
     return !this.isLoaded && this.pendingCount > 0 && this.fulfilledCount === 0;
   }
   static {
-    decorateMethodV2(this.prototype, "isLoading", [tagged]);
+    decorateMethodV2(this.prototype, "isLoading", [subscribed]);
   }
   get isLoaded() {
     if (this.isNew) {
@@ -3539,7 +3040,7 @@ class RecordState {
     return this.fulfilledCount > 0 || !this.isEmpty;
   }
   static {
-    decorateMethodV2(this.prototype, "isLoaded", [tagged]);
+    decorateMethodV2(this.prototype, "isLoaded", [subscribed]);
   }
   get isSaved() {
     const rd = this.cache;
@@ -3557,7 +3058,7 @@ class RecordState {
     return true;
   }
   static {
-    decorateMethodV2(this.prototype, "isSaved", [tagged]);
+    decorateMethodV2(this.prototype, "isSaved", [subscribed]);
   }
   get isEmpty() {
     const rd = this.cache;
@@ -3571,7 +3072,7 @@ class RecordState {
     return !this.isNew && rd.isEmpty(this.identifier);
   }
   static {
-    decorateMethodV2(this.prototype, "isEmpty", [tagged]);
+    decorateMethodV2(this.prototype, "isEmpty", [subscribed]);
   }
   get isNew() {
     const rd = this.cache;
@@ -3583,7 +3084,7 @@ class RecordState {
     return rd.isNew(this.identifier);
   }
   static {
-    decorateMethodV2(this.prototype, "isNew", [tagged]);
+    decorateMethodV2(this.prototype, "isNew", [subscribed]);
   }
   get isDeleted() {
     const rd = this.cache;
@@ -3595,13 +3096,13 @@ class RecordState {
     return rd.isDeleted(this.identifier);
   }
   static {
-    decorateMethodV2(this.prototype, "isDeleted", [tagged]);
+    decorateMethodV2(this.prototype, "isDeleted", [subscribed]);
   }
   get isValid() {
     return this.record.errors.length === 0;
   }
   static {
-    decorateMethodV2(this.prototype, "isValid", [tagged]);
+    decorateMethodV2(this.prototype, "isValid", [subscribed]);
   }
   get isDirty() {
     const rd = this.cache;
@@ -3611,7 +3112,7 @@ class RecordState {
     return this.isDeleted || this.isNew || rd.hasChangedAttrs(this.identifier);
   }
   static {
-    decorateMethodV2(this.prototype, "isDirty", [tagged]);
+    decorateMethodV2(this.prototype, "isDirty", [subscribed]);
   }
   get isError() {
     const errorReq = this._errorRequests[this._errorRequests.length - 1];
@@ -3622,7 +3123,7 @@ class RecordState {
     }
   }
   static {
-    decorateMethodV2(this.prototype, "isError", [tagged]);
+    decorateMethodV2(this.prototype, "isError", [subscribed]);
   }
   get adapterError() {
     const request = this._lastError;
@@ -3632,7 +3133,7 @@ class RecordState {
     return request.state === 'rejected' && request.response.data;
   }
   static {
-    decorateMethodV2(this.prototype, "adapterError", [tagged]);
+    decorateMethodV2(this.prototype, "adapterError", [subscribed]);
   }
   get isPreloaded() {
     return !this.isEmpty && this.isLoading;
@@ -3864,9 +3365,8 @@ 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
@@ -3889,11 +3389,10 @@ 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
@@ -4094,9 +3593,8 @@ 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
@@ -4116,7 +3614,7 @@ class Model extends EmberObject {
     return recordIdentifierFor$1(this).id;
   }
   static {
-    decorateMethodV2(this.prototype, "id", [tagged]);
+    decorateMethodV2(this.prototype, "id", [subscribed]);
   }
   set id(id) {
     const normalizedId = coerceId(id);
@@ -4156,7 +3654,7 @@ class Model extends EmberObject {
     return this.___recordState;
   }
   static {
-    decorateMethodV2(this.prototype, "currentState", [tagged]);
+    decorateMethodV2(this.prototype, "currentState", [subscribed]);
   }
   set currentState(_v) {
     throw new Error('cannot set currentState');
@@ -5169,7 +4667,7 @@ class Model extends EmberObject {
       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());
+            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') : {};
 
@@ -5404,4 +4902,4 @@ function isRelationshipSchema(meta) {
 function isAttributeSchema(meta) {
   return typeof meta === 'object' && meta !== null && 'kind' in meta && meta.kind === 'attribute';
 }
-export { Errors as E, LEGACY_SUPPORT as L, Model as M, PromiseBelongsTo as P, RelatedCollection as R, PromiseManyArray as a, save as b, reload as c, destroyRecord as d, deleteRecord as e, RecordState as f, changedAttributes as g, hasMany as h, belongsTo as i, createSnapshot as j, isElementDescriptor as k, lookupLegacySupport as l, normalizeModelName as n, 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 };