@warp-drive/legacy 5.7.0-alpha.9 → 5.7.0-beta.0

package/dist/{errors-BX5wowuz.js → errors-8kD2mSe_.js}

@@ -1,7 +1,8 @@
-import { memoized, defineSignal, defineNonEnumerableSignal, isStableIdentifier, recordIdentifierFor, storeFor, peekCache, SOURCE, fastPush, RelatedCollection, notifyInternalSignal, ARRAY_SIGNAL } from '@warp-drive/core/store/-private';
+import { Context } from '@warp-drive/core/reactive/-private';
+import { memoized, defineSignal, assertPrivateStore, defineNonEnumerableSignal, isResourceKey, recordIdentifierFor, isPrivateStore, storeFor, fastPush, createLegacyManyArray, notifyInternalSignal } from '@warp-drive/core/store/-private';
 import { getOrSetGlobal } from '@warp-drive/core/types/-private';
 import { EnableHydration } from '@warp-drive/core/types/request';
-import { u as upgradeStore } from "./-private-CKrP0ogQ.js";
+import { u as upgradeStore } from "./-private-8UmnAf9J.js";
 import { computed, get } from '@ember/object';
 import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
 import ObjectProxy from '@ember/object/proxy';
@@ -420,7 +421,7 @@ class HasManyReference {
    * An array of identifiers for the records that this reference refers to.
    *
    * @property identifiers
-   * @type {StableRecordIdentifier[]}
+   * @type {ResourceKey[]}
    * @public
    */
   get identifiers() {
@@ -432,7 +433,7 @@ class HasManyReference {
     this.___relatedTokenMap = new Map();
     if (resource && resource.data) {
       return resource.data.map(resourceIdentifier => {
-        const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);
+        const identifier = this.store.cacheKeyManager.getOrCreateRecordIdentifier(resourceIdentifier);
         let token = map.get(identifier);
         if (token) {
           map.delete(identifier);
@@ -724,7 +725,7 @@ class HasManyReference {
         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 identifiers = !Array.isArray(dataDoc.data) ? [] : isResourceData ? store._push(dataDoc, true) : dataDoc.data.map(i => store.cacheKeyManager.getOrCreateRecordIdentifier(i));
     const {
       identifier
     } = this.hasManyRelationship;
@@ -745,6 +746,7 @@ class HasManyReference {
     if ('meta' in dataDoc) {
       newData.meta = dataDoc.meta;
     }
+    assertPrivateStore(store);
     store._join(() => {
       this.graph.push({
         op: 'updateRelationship',
@@ -762,6 +764,7 @@ class HasManyReference {
     }
     const relationship = this.graph.getData(this.hasManyRelationship.identifier, this.key);
     return relationship.data ? relationship.data.every(identifier => {
+      assertPrivateStore(this.store);
       return this.store._instanceCache.recordIsLoaded(identifier, true) === true;
     }) : false;
   }
@@ -1022,7 +1025,7 @@ class BelongsToReference {
    * `null` if no related record is known.
    *
    * @property identifier
-   * @type {StableRecordIdentifier | null}
+   * @type {ResourceKey | null}
    * @public
    */
   get identifier() {
@@ -1032,7 +1035,7 @@ class BelongsToReference {
     }
     const resource = this._resource();
     if (resource && resource.data) {
-      const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource.data);
+      const identifier = this.store.cacheKeyManager.getOrCreateRecordIdentifier(resource.data);
       this.___relatedToken = this.store.notifications.subscribe(identifier, (_, bucket, notifiedKey) => {
         if (bucket === 'identity' || bucket === 'attributes' && notifiedKey === 'id') {
           this._ref++;
@@ -1309,7 +1312,7 @@ class BelongsToReference {
       store
     } = this;
     const isResourceData = doc.data && isMaybeResource(doc.data);
-    const added = isResourceData ? store._push(doc, true) : doc.data ? store.identifierCache.getOrCreateRecordIdentifier(doc.data) : null;
+    const added = isResourceData ? store._push(doc, true) : doc.data ? store.cacheKeyManager.getOrCreateRecordIdentifier(doc.data) : null;
     const {
       identifier
     } = this.belongsToRelationship;
@@ -1330,6 +1333,7 @@ class BelongsToReference {
     if ('meta' in doc) {
       newData.meta = doc.meta;
     }
+    assertPrivateStore(store);
     store._join(() => {
       this.graph.push({
         op: 'updateRelationship',
@@ -1508,18 +1512,43 @@ function lookupLegacySupport(record) {
         throw new Error(`Memory Leak Detected`);
       }
     })(!record.isDestroyed && !record.isDestroying) : {};
-    support = new LegacySupport(record);
+    support = new LegacySupport(record, identifier);
     LEGACY_SUPPORT.set(identifier, support);
-    LEGACY_SUPPORT.set(record, support);
   }
   return support;
 }
+
+/**
+ * @hideconstructor
+ */
 class LegacySupport {
-  constructor(record) {
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  constructor(record, identifier) {
     this.record = record;
-    this.store = storeFor(record);
-    this.identifier = recordIdentifierFor(record);
-    this.cache = peekCache(record);
+    this.store = isPrivateStore(storeFor(record, false));
+    this.identifier = identifier;
+    this.cache = this.store.cache;
     if (this.store._graph) {
       this.graph = this.store._graph;
     }
@@ -1529,12 +1558,14 @@ class LegacySupport {
     this._pending = Object.create(null);
     this.references = Object.create(null);
   }
+
+  /** @private */
   _syncArray(array) {
     // It’s possible the parent side of the relationship may have been destroyed by this point
     if (this.isDestroyed || this.isDestroying) {
       return;
     }
-    const currentState = array[SOURCE];
+    const currentState = array[Context].source;
     const identifier = this.identifier;
     const [identifiers, jsonApi] = this._getCurrentState(identifier, array.key);
     if (jsonApi.meta) {
@@ -1588,7 +1619,7 @@ class LegacySupport {
       if (!test) {
         throw new Error(`Expected a stable identifier`);
       }
-    })(!relatedIdentifier || isStableIdentifier(relatedIdentifier)) : {};
+    })(!relatedIdentifier || isResourceKey(relatedIdentifier)) : {};
     const store = this.store;
     const relationship = this.graph.get(this.identifier, key);
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -1648,7 +1679,7 @@ class LegacySupport {
           if (!test) {
             throw new Error(`Expected a stable identifier`);
           }
-        })(isStableIdentifier(relatedIdentifier)) : {};
+        })(isResourceKey(relatedIdentifier)) : {};
         if (cache.recordIsLoaded(relatedIdentifier, true)) {
           identifiers.push(relatedIdentifier);
         }
@@ -1664,23 +1695,20 @@ class LegacySupport {
       }
       if (!manyArray) {
         const [identifiers, doc] = this._getCurrentState(this.identifier, key);
-        manyArray = new RelatedCollection({
+        manyArray = createLegacyManyArray({
           store: this.store,
-          type: definition.type,
-          identifier: this.identifier,
-          cache: this.cache,
-          field: this.store.schema.fields(this.identifier).get(key),
-          identifiers,
-          key,
-          meta: doc.meta || null,
-          links: doc.links || null,
-          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,
+          source: identifiers,
+          type: definition.type,
           isLoaded: !definition.isAsync,
-          allowMutation: true
+          editable: true,
+          isAsync: definition.isAsync,
+          isPolymorphic: definition.isPolymorphic,
+          field: this.store.schema.fields(this.identifier).get(key),
+          identifier: this.identifier,
+          links: doc.links || null,
+          meta: doc.meta || null
         });
         this._manyArrayCache[key] = manyArray;
       }
@@ -1901,7 +1929,7 @@ class LegacySupport {
           if (!test) {
             throw new Error(`Expected stable identifiers`);
           }
-        })(!identifiers || identifiers.every(isStableIdentifier)) : {};
+        })(!identifiers || identifiers.every(isResourceKey)) : {};
         const req = field.options.linksMode ? {
           url: getRelatedLink(resource),
           op: 'findHasMany',
@@ -1936,7 +1964,7 @@ class LegacySupport {
           if (!test) {
             throw new Error(`Expected stable identifiers`);
           }
-        })(identifiers.every(isStableIdentifier)) : {};
+        })(identifiers.every(isResourceKey)) : {};
         options.reload = options.reload || !attemptLocalCache || undefined;
         return this.store.request({
           op: 'findHasMany',
@@ -1975,7 +2003,7 @@ class LegacySupport {
       if (!test) {
         throw new Error(`Expected a stable identifier`);
       }
-    })(!identifier || isStableIdentifier(identifier)) : {};
+    })(!identifier || isResourceKey(identifier)) : {};
     const {
       isStale,
       hasDematerializedInverse,
@@ -2104,7 +2132,7 @@ function handleCompletedRelationshipRequest(recordExt, key, relationship, value,
   if (isHasMany) {
     // we don't notify the record property here to avoid refetch
     // only the many array
-    notifyInternalSignal(value[ARRAY_SIGNAL]);
+    notifyInternalSignal(value[Context].signal);
   }
   if (error) {
     relationship.state.hasFailedLoadAttempt = true;
@@ -2142,6 +2170,7 @@ function extractIdentifierFromRecord(record) {
   return recordIdentifierFor(record);
 }
 function anyUnloaded(store, relationship) {
+  assertPrivateStore(store);
   const graph = store._graph;
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
     if (!test) {
@@ -2158,6 +2187,7 @@ function anyUnloaded(store, relationship) {
   return unloaded || false;
 }
 function areAllInverseRecordsLoaded(store, resource) {
+  assertPrivateStore(store);
   const instanceCache = store._instanceCache;
   const identifiers = resource.data;
   if (Array.isArray(identifiers)) {
@@ -2165,7 +2195,7 @@ function areAllInverseRecordsLoaded(store, resource) {
       if (!test) {
         throw new Error(`Expected stable identifiers`);
       }
-    })(identifiers.every(isStableIdentifier)) : {};
+    })(identifiers.every(isResourceKey)) : {};
     // treat as collection
     // check for unloaded records
     return identifiers.every(identifier => instanceCache.recordIsLoaded(identifier));
@@ -2177,7 +2207,7 @@ function areAllInverseRecordsLoaded(store, resource) {
     if (!test) {
       throw new Error(`Expected stable identifiers`);
     }
-  })(isStableIdentifier(identifiers)) : {};
+  })(isResourceKey(identifiers)) : {};
   return instanceCache.recordIsLoaded(identifiers);
 }
 function isBelongsTo(relationship) {

package/dist/model/-private.js

@@ -1,2 +1 @@
-export { E as Errors, L as LEGACY_SUPPORT, P as PromiseBelongsTo, a as PromiseManyArray, l as lookupLegacySupport } from "../errors-BX5wowuz.js";
-export { RelatedCollection as ManyArray } from '@warp-drive/core/store/-private';
+export { E as Errors, L as LEGACY_SUPPORT, P as PromiseBelongsTo, a as PromiseManyArray, l as lookupLegacySupport } from "../errors-8kD2mSe_.js";

package/dist/model/migration-support.js

@@ -1,10 +1,11 @@
 import { deprecate } from '@ember/debug';
 import { recordIdentifierFor } from '@warp-drive/core';
-import { notifyInternalSignal, ARRAY_SIGNAL } from '@warp-drive/core/store/-private';
+import { Context } from '@warp-drive/core/reactive/-private';
+import { notifyInternalSignal, assertPrivateStore } from '@warp-drive/core/store/-private';
 import { getOrSetGlobal } from '@warp-drive/core/types/-private';
 import { Type } from '@warp-drive/core/types/symbols';
-import { l as lookupLegacySupport, E as Errors } from "../errors-BX5wowuz.js";
-import { b as buildSchema, u as unloadRecord, s as serialize, _ as _save, a as save, r as rollbackAttributes, c as _reload, d as reload, h as hasMany, e as _destroyRecord, f as destroyRecord, g as deleteRecord, R as RecordState, i as changedAttributes, j as belongsTo, k as createSnapshot } from "../schema-provider-Cbnf6sKm.js";
+import { l as lookupLegacySupport, E as Errors } from "../errors-8kD2mSe_.js";
+import { b as buildSchema, u as unloadRecord, s as serialize, _ as _save, a as save, r as rollbackAttributes, c as _reload, d as reload, h as hasMany, e as _destroyRecord, f as destroyRecord, g as deleteRecord, R as RecordState, i as changedAttributes, j as belongsTo, k as createSnapshot } from "../schema-provider-DQu4Rjco.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 
 /**
@@ -314,6 +315,7 @@ function registerDerivations(schema) {
         return lookupLegacySupport(record).getBelongsTo(field.name);
       },
       set(store, record, cacheKey, field, value) {
+        assertPrivateStore(store);
         store._join(() => {
           // FIXME field.name here should likely be field.sourceKey || field.name
           lookupLegacySupport(record).setDirtyBelongsTo(field.name, value);
@@ -326,6 +328,7 @@ function registerDerivations(schema) {
         return lookupLegacySupport(record).getHasMany(field.name);
       },
       set(store, record, cacheKey, field, value) {
+        assertPrivateStore(store);
         store._join(() => {
           const support = lookupLegacySupport(record);
           // FIXME field.name here should likely be field.sourceKey || field.name
@@ -344,7 +347,7 @@ function registerDerivations(schema) {
           return false;
         }
         if (manyArray) {
-          notifyInternalSignal(manyArray[ARRAY_SIGNAL]);
+          notifyInternalSignal(manyArray[Context].signal);
           return true;
         }
         return false;

package/dist/model.js

@@ -1,14 +1,14 @@
 import { computed } from '@ember/object';
 import { recordIdentifierFor } from '@warp-drive/core';
-import { peekCache, setRecordIdentifier, StoreMap, setCacheFor } from '@warp-drive/core/store/-private';
+import { RecordStore } from '@warp-drive/core/types/symbols';
 import { i as isElementDescriptor, n as normalizeModelName } from "./util-Dul6TZts.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { warn, deprecate } from '@ember/debug';
-import { RecordStore } from '@warp-drive/core/types/symbols';
-import { l as lookupLegacySupport } from "./errors-BX5wowuz.js";
+import { assertPrivateStore, setRecordIdentifier, StoreMap } from '@warp-drive/core/store/-private';
+import { l as lookupLegacySupport } from "./errors-8kD2mSe_.js";
 import { singularize, dasherize } from '@warp-drive/utilities/string';
-import { l as getModelFactory } from "./schema-provider-Cbnf6sKm.js";
-export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-Cbnf6sKm.js";
+import { l as getModelFactory } from "./schema-provider-DQu4Rjco.js";
+export { M as Model, b as buildSchema, M as default, m as restoreDeprecatedModelRequestBehaviors } from "./schema-provider-DQu4Rjco.js";
 import { setOwner, getOwner } from '@ember/application';
 function _attr(type, options) {
   if (typeof type === 'object') {
@@ -34,7 +34,8 @@ function _attr(type, options) {
       if (this.isDestroyed || this.isDestroying) {
         return;
       }
-      return peekCache(this).getAttr(recordIdentifierFor(this), key);
+      const cache = this[RecordStore].cache;
+      return cache.getAttr(recordIdentifierFor(this), key);
     },
     set(key, value) {
       if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
@@ -48,7 +49,7 @@ function _attr(type, options) {
           throw new Error(`Attempted to set '${key}' on the deleted record ${identifier.type}:${identifier.id} (${identifier.lid})`);
         }
       })(!this.currentState.isDeleted) : {};
-      const cache = peekCache(this);
+      const cache = this[RecordStore].cache;
       const currentValue = cache.getAttr(identifier, key);
       if (currentValue !== value) {
         cache.setAttr(identifier, key, value);
@@ -246,6 +247,7 @@ function _belongsTo(type, options) {
           throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your belongsTo on ${this.constructor.toString()}`);
         }
       }
+      assertPrivateStore(this[RecordStore]);
       this[RecordStore]._join(() => {
         support.setDirtyBelongsTo(key, value);
       });
@@ -484,6 +486,7 @@ function _hasMany(type, options) {
           throw new Error(`You must pass an array of records to set a hasMany relationship`);
         }
       })(Array.isArray(records)) : {};
+      assertPrivateStore(this[RecordStore]);
       this[RecordStore]._join(() => {
         manyArray.splice(0, manyArray.length, ...records);
       });
@@ -667,14 +670,13 @@ function hasMany(type, options) {
 }
 function instantiateRecord(identifier, createRecordArgs) {
   const type = identifier.type;
-  const cache = this.cache;
+
   // TODO deprecate allowing unknown args setting
   const createOptions = {
     _createProps: createRecordArgs,
     // TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
     _secretInit: {
       identifier,
-      cache,
       store: this,
       cb: secretInit
     }
@@ -699,6 +701,7 @@ function teardownRecord(record) {
   record.destroy();
 }
 function modelFor(modelName) {
+  assertPrivateStore(this);
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
     if (!test) {
       throw new Error(`Attempted to call store.modelFor(), but the store instance has already been destroyed.`);
@@ -729,9 +732,8 @@ function modelFor(modelName) {
     type
   })) : {};
 }
-function secretInit(record, cache, identifier, store) {
+function secretInit(record, identifier, store) {
   setRecordIdentifier(record, identifier);
   StoreMap.set(record, store);
-  setCacheFor(record, cache);
 }
 export { attr, belongsTo, hasMany, instantiateRecord, modelFor, teardownRecord };

package/dist/{schema-provider-Cbnf6sKm.js → schema-provider-DQu4Rjco.js}

@@ -2,12 +2,13 @@ import { getOwner } from '@ember/application';
 import { deprecate } from '@ember/debug';
 import EmberObject from '@ember/object';
 import { recordIdentifierFor, storeFor } from '@warp-drive/core';
-import { peekCache, notifyInternalSignal, peekInternalSignal, withSignalStore, ARRAY_SIGNAL, recordIdentifierFor as recordIdentifierFor$1, gate, memoized, defineSignal, coerceId, entangleSignal, defineGate } from '@warp-drive/core/store/-private';
+import { assertPrivateStore, notifyInternalSignal, peekInternalSignal, withSignalStore, recordIdentifierFor as recordIdentifierFor$1, gate, memoized, defineSignal, coerceId, entangleSignal, defineGate } from '@warp-drive/core/store/-private';
 import { RecordStore } from '@warp-drive/core/types/symbols';
-import { l as lookupLegacySupport, L as LEGACY_SUPPORT, E as Errors } from "./errors-BX5wowuz.js";
-import { u as upgradeStore, F as FetchManager } from "./-private-CKrP0ogQ.js";
+import { l as lookupLegacySupport, L as LEGACY_SUPPORT, E as Errors } from "./errors-8kD2mSe_.js";
+import { u as upgradeStore, F as FetchManager } from "./-private-8UmnAf9J.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { cacheFor } from '@ember/object/internals';
+import { Context } from '@warp-drive/core/reactive/-private';
 import { d as decorateMethodV2 } from "./runtime-BPCpkOf1-BKOwiRJp.js";
 import { n as normalizeModelName } from "./util-Dul6TZts.js";
 function rollbackAttributes() {
@@ -17,8 +18,10 @@ function rollbackAttributes() {
   const {
     isNew
   } = currentState;
-  this[RecordStore]._join(() => {
-    peekCache(this).rollbackAttrs(recordIdentifierFor(this));
+  const store = this[RecordStore];
+  assertPrivateStore(store);
+  store._join(() => {
+    store.cache.rollbackAttrs(recordIdentifierFor(this));
     this.errors.clear();
     currentState.cleanErrorRequests();
     if (isNew) {
@@ -84,7 +87,7 @@ function _reload(options = {}) {
   return promise;
 }
 function changedAttributes() {
-  return peekCache(this).changedAttrs(recordIdentifierFor(this));
+  return this[RecordStore].cache.changedAttrs(recordIdentifierFor(this));
 }
 function serialize(options) {
   upgradeStore(this[RecordStore]);
@@ -215,7 +218,7 @@ function notifyRelationship(identifier, key, record, meta) {
       return;
     }
     if (manyArray) {
-      notifyInternalSignal(manyArray[ARRAY_SIGNAL]);
+      notifyInternalSignal(manyArray[Context].signal);
 
       //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
@@ -287,11 +290,34 @@ root
     invalid
     inFlight
 
-  @internal
+  @hideconstructor
+  @private
 */
 class RecordState {
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
   constructor(record) {
-    const store = storeFor(record);
+    const store = storeFor(record, false);
     const identity = recordIdentifierFor$1(record);
     this.identifier = identity;
     this.record = record;
@@ -382,7 +408,7 @@ class RecordState {
 
   /** @internal */
   destroy() {
-    storeFor(this.record).notifications.unsubscribe(this.handler);
+    storeFor(this.record, false).notifications.unsubscribe(this.handler);
   }
 
   /** @internal */
@@ -719,7 +745,7 @@ class Model extends EmberObject {
     super.init(options);
     this[RecordStore] = store;
     const identity = _secretInit.identifier;
-    _secretInit.cb(this, _secretInit.cache, identity, _secretInit.store);
+    _secretInit.cb(this, identity, _secretInit.store);
     this.___recordState = macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? new RecordState(this) : null;
     this.setProperties(createProps);
     const notifications = store.notifications;
@@ -728,16 +754,18 @@ class Model extends EmberObject {
     });
   }
 
-  /** @internal */
+  /** @private */
   // @ts-expect-error destroy should not return a value, but ember's types force it to
   destroy() {
     const identifier = recordIdentifierFor(this);
     this.___recordState?.destroy();
-    const store = storeFor(this);
+    const store = storeFor(this, false);
     store.notifications.unsubscribe(this.___private_notifications);
-    LEGACY_SUPPORT.get(this)?.destroy();
-    LEGACY_SUPPORT.delete(this);
-    LEGACY_SUPPORT.delete(identifier);
+    const support = LEGACY_SUPPORT.get(identifier);
+    if (support) {
+      support.destroy();
+      LEGACY_SUPPORT.delete(identifier);
+    }
     super.destroy();
   }
 
@@ -1027,6 +1055,7 @@ class Model extends EmberObject {
     const normalizedId = coerceId(id);
     const identifier = recordIdentifierFor(this);
     const didChange = normalizedId !== identifier.id;
+    assertPrivateStore(this.store);
     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}`);
@@ -1034,7 +1063,7 @@ class Model extends EmberObject {
     })(!didChange || identifier.id === null) : {};
     if (normalizedId !== null && didChange) {
       this.store._instanceCache.setRecordId(identifier, normalizedId);
-      this.store.notifications.notify(identifier, 'identity');
+      this.store.notifications.notify(identifier, 'identity', null);
     }
   }
   toString() {
@@ -1202,8 +1231,8 @@ class Model extends EmberObject {
   }
    ```
     @public
-   @param {Function} callback the callback to invoke
-   @param {any} binding the value to which the callback's `this` should be bound
+   @param callback the callback to invoke
+   @param binding the value to which the callback's `this` should be bound
    */
   eachRelationship(callback, binding) {
     this.constructor.eachRelationship(callback, binding);
@@ -1212,7 +1241,7 @@ class Model extends EmberObject {
     return this.constructor.relationshipsByName.get(name);
   }
   inverseFor(name) {
-    return this.constructor.inverseFor(name, storeFor(this));
+    return this.constructor.inverseFor(name, storeFor(this, false));
   }
   eachAttribute(callback, binding) {
     this.constructor.eachAttribute(callback, binding);
@@ -1274,9 +1303,9 @@ class Model extends EmberObject {
    ```
     Calling `store.modelFor('post').typeForRelationship('comments', store)` will return `Comment`.
      @public
-   @param {String} name the name of the relationship
-   @param {store} store an instance of Store
-   @return {Model} the type of the relationship, or undefined
+   @param name the name of the relationship
+   @param store an instance of Store
+   @return the type of the relationship, or undefined
    */
   static typeForRelationship(name, store) {
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -1316,9 +1345,9 @@ class Model extends EmberObject {
    store.modelFor('message').inverseFor('owner', store) // { type: 'post', name: 'comments', kind: 'hasMany' }
    ```
      @public
-   @param {String} name the name of the relationship
-   @param {Store} store
-   @return {Object} the inverse relationship, or null
+   @param name the name of the relationship
+   @param store
+   @return the inverse relationship, or null
    */
   static {
     decorateMethodV2(this, "inverseMap", [computeOnce]);
@@ -2068,6 +2097,12 @@ function modelForMixin(store, normalizedModelName) {
   return owner.factoryFor(`model:${normalizedModelName}`);
 }
 class ModelSchemaProvider {
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
   constructor(store) {
     this.store = store;
     this._schemas = new Map();
@@ -2155,6 +2190,7 @@ class ModelSchemaProvider {
       }
     })() : {};
   }
+  /** @internal */
   _loadModelSchema(type) {
     const modelClass = this.store.modelFor(type);
     const attributeMap = modelClass.attributes;

package/dist/{serialize-into-hash-Bp58npke.js → serialize-into-hash-CS0MIv4F.js}

@@ -1,7 +1,8 @@
 import { warn } from '@ember/debug';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
+import '@warp-drive/core/reactive/-private';
+import "./-private-8UmnAf9J.js";
 import '@warp-drive/core/store/-private';
-import "./-private-CKrP0ogQ.js";
 const newline = /\r?\n/;
 function parseResponseHeaders(headersString) {
   const headers = Object.create(null);