@warp-drive/core 5.7.0-alpha.13 → 5.7.0-alpha.14

package/dist/{request-state-BWYju5O9.js → request-state-CCrTjb0Z.js}

@@ -5,10 +5,10 @@ import { setLogging, getRuntimeConfig } from './types/runtime.js';
 import { getOrSetGlobal, peekTransient, setTransient } from './types/-private.js';
 import { CACHE_OWNER, DEBUG_STALE_CACHE_OWNER, DEBUG_IDENTIFIER_BUCKET, DEBUG_CLIENT_ORIGINATED } from './types/identifier.js';
 import { dasherize } from './utils/string.js';
+import { S as SOURCE, C as Context, D as Destroy, a as Checkout } from "./symbols-C5p2hcy9.js";
 import { a as createSignal, b as consumeSignal, n as notifySignal, c as createMemo, A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, d as willSyncFlushWatchers } from "./configure-B48bFHOl.js";
-import { g as getPromiseResult, s as setPromiseResult } from "./context-COmAnXUQ.js";
+import { g as getPromiseResult, s as setPromiseResult } from "./context-kQXhkeBj.js";
 import { RecordStore } from './types/symbols.js';
-import { S as SOURCE$1, C as Context, D as Destroy, a as Checkout } from "./symbols-BoONANuz.js";
 function coerceId(id) {
   if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_NON_STRICT_ID)) {
     let normalized;
@@ -1001,7 +1001,7 @@ const Signals = getOrSetGlobal('Signals', Symbol('Signals'));
  * @internal
  */
 function withSignalStore(obj) {
-  if (obj[Signals] === undefined) {
+  if (!obj[Signals]) {
     initializeSignalStore(obj);
   }
   return obj[Signals];
@@ -1021,7 +1021,7 @@ function initializeSignalStore(obj) {
     if (!test) {
       throw new Error(`Signal store already exists on object`);
     }
-  })(obj[Signals] === undefined) : {};
+  })(!obj[Signals]) : {};
   obj[Signals] = new Map();
 }
 function createInternalSignal(signals, obj, key, initialValue) {
@@ -1437,11 +1437,11 @@ defineGate(ReactiveDocument.prototype, 'data', {
     })(doc) : {};
     const data = 'data' in doc ? doc.data : undefined;
     if (Array.isArray(data)) {
-      return this._store.recordArrayManager.getCollection({
-        type: identifier ? identifier.lid : _localCache.request.url,
-        identifiers: data.slice(),
-        doc: identifier ? undefined : doc,
-        identifier: identifier ?? null
+      return identifier ? this._store.recordArrayManager.getCollection({
+        source: data.slice(),
+        requestKey: identifier
+      }) : this._store.recordArrayManager.getCollection({
+        source: data.slice()
       });
     } else if (data) {
       return this._store.peekRecord(data);
@@ -1637,7 +1637,7 @@ function performArrayExtensionGet(receiver, extensions, signals, prop, _SIGNAL,
 }
 const ARRAY_GETTER_METHODS$1 = new Set([Symbol.iterator, 'concat', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'flat', 'flatMap', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'map', 'reduce', 'reduceRight', 'slice', 'some', 'values']);
 // const ARRAY_SETTER_METHODS = new Set<KeyType>(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
-const SYNC_PROPS$1 = new Set(['[]', 'length']);
+const SYNC_PROPS = new Set(['[]', 'length']);
 function isArrayGetter$1(prop) {
   return ARRAY_GETTER_METHODS$1.has(prop);
 }
@@ -1684,7 +1684,7 @@ class ManagedArray {
   constructor(context, owner, data) {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
-    this[SOURCE$1] = data?.slice();
+    this[SOURCE] = data?.slice();
     const IS_EDITABLE = context.editable ?? false;
     this[Context] = context;
     const schema = context.store.schema;
@@ -1711,7 +1711,7 @@ class ManagedArray {
     Map;
     const ManagedRecordRefs = field.kind === 'schema-array' ? new RefStorage() : null;
     const extensions = context.legacy ? schema.CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field) : null;
-    const proxy = new Proxy(this[SOURCE$1], {
+    const proxy = new Proxy(this[SOURCE], {
       get(target, prop, receiver) {
         if (prop === ARRAY_SIGNAL) {
           return _SIGNAL;
@@ -1723,12 +1723,12 @@ class ManagedArray {
           return self.owner;
         }
         const index = convertToInt$1(prop);
-        if (_SIGNAL.isStale && (index !== null || SYNC_PROPS$1.has(prop) || isArrayGetter$1(prop))) {
+        if (_SIGNAL.isStale && (index !== null || SYNC_PROPS.has(prop) || isArrayGetter$1(prop))) {
           _SIGNAL.isStale = false;
           const newData = cache.getAttr(context.resourceKey, context.path);
-          if (newData && newData !== self[SOURCE$1]) {
-            self[SOURCE$1].length = 0;
-            self[SOURCE$1].push(...newData);
+          if (newData && newData !== self[SOURCE]) {
+            self[SOURCE].length = 0;
+            self[SOURCE].push(...newData);
           }
         }
         if (prop === 'length') {
@@ -1834,7 +1834,7 @@ class ManagedArray {
             }
             schemaObjectKeyValue = KeyMode === '@identity' ? rawValue : KeyMode === '@index' ? index : rawValue[KeyMode];
           }
-          if (!schemaObjectKeyValue) {
+          if (!schemaObjectKeyValue && schemaObjectKeyValue !== 0) {
             macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
               {
                 throw new Error(`Unexpected out of bounds access on SchemaArray`);
@@ -1952,17 +1952,17 @@ class ManagedArray {
         const reflect = Reflect.set(target, prop, value, receiver);
         if (reflect) {
           if (!field.type) {
-            cache.setAttr(context.resourceKey, context.path, self[SOURCE$1]);
+            cache.setAttr(context.resourceKey, context.path, self[SOURCE]);
             _SIGNAL.isStale = true;
             return true;
           }
-          let rawValue = self[SOURCE$1];
+          let rawValue = self[SOURCE];
           if (field.kind !== 'schema-array') {
             const transform = schema.transformation(field);
             if (!transform) {
               throw new Error(`No '${field.type}' transform defined for use by ${context.resourceKey.type}.${String(prop)}`);
             }
-            rawValue = self[SOURCE$1].map(item => transform.serialize(item, field.options ?? null, self.owner));
+            rawValue = self[SOURCE].map(item => transform.serialize(item, field.options ?? null, self.owner));
           }
           cache.setAttr(context.resourceKey, context.path, rawValue);
           _SIGNAL.isStale = true;
@@ -1988,7 +1988,7 @@ class ManagedArray {
 // A(identifierArray) since it is not configurable
 // which is preferable to the `meta` override we used
 // before which required importing all of Ember
-const desc$1 = {
+const desc = {
   enumerable: true,
   configurable: false,
   get: function () {
@@ -2000,7 +2000,7 @@ const desc$1 = {
   }
 };
 // compat(desc);
-Object.defineProperty(ManagedArray.prototype, '[]', desc$1);
+Object.defineProperty(ManagedArray.prototype, '[]', desc);
 function getArrayField(context) {
   const signal = entangleSignal(context.signals, context.record, context.path.at(-1), null);
   // the thing we hand out needs to know its owner and path in a private manner
@@ -2210,7 +2210,7 @@ class ManyArrayManager {
     if (rawValue.links) {
       array.links = rawValue.links;
     }
-    const currentState = array[SOURCE];
+    const currentState = array[Context].source;
 
     // unlike in the normal RecordArray case, we don't need to divorce the reference
     // because we don't need to worry about associate/disassociate since the graph
@@ -2303,26 +2303,19 @@ function getHasManyField(context) {
     if (!rawValue) {
       return null;
     }
-    const managedArray = new RelatedCollection({
+    const managedArray = createLegacyManyArray({
       store,
+      manager: new ManyArrayManager(record, editable),
+      source: rawValue.data?.slice() ?? [],
       type: field.type,
+      isLoaded: true,
+      editable,
+      isAsync: field.options.async ?? false,
+      isPolymorphic: field.options.polymorphic ?? false,
+      field,
       identifier: resourceKey,
-      cache,
-      field: context.legacy ? field : undefined,
-      // we divorce the reference here because ManyArray mutates the target directly
-      // before sending the mutation op to the cache. We may be able to avoid this in the future
-      identifiers: rawValue.data?.slice(),
-      key: field.name,
-      meta: rawValue.meta || null,
       links: rawValue.links || null,
-      isPolymorphic: field.options.polymorphic ?? false,
-      isAsync: field.options.async ?? false,
-      // TODO: Grab the proper value
-      _inverseIsAsync: false,
-      // @ts-expect-error Typescript doesn't have a way for us to thread the generic backwards so it infers unknown instead of T
-      manager: new ManyArrayManager(record, editable),
-      isLoaded: true,
-      allowMutation: editable
+      meta: rawValue.meta || null
     });
     signal.value = managedArray;
     return managedArray;
@@ -2402,7 +2395,7 @@ function setIdentityField(context) {
   })(!didChange || resourceKey.id === null) : {};
   if (normalizedId !== null && didChange) {
     store._instanceCache.setRecordId(resourceKey, normalizedId);
-    store.notifications.notify(resourceKey, 'identity');
+    store.notifications.notify(resourceKey, 'identity', null);
   }
   return true;
 }
@@ -2425,7 +2418,7 @@ function setLocalField(context) {
   }
   return true;
 }
-const ObjectSymbols = new Set([OBJECT_SIGNAL, Context, SOURCE$1]);
+const ObjectSymbols = new Set([OBJECT_SIGNAL, Context, SOURCE]);
 
 // const ignoredGlobalFields = new Set<string>(['setInterval', 'nodeType', 'nodeName', 'length', 'document', STRUCTURED]);
 
@@ -2438,7 +2431,7 @@ class ManagedObject {
     } = context;
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
-    this[SOURCE$1] = Object.assign({}, context.value);
+    this[SOURCE] = Object.assign({}, context.value);
     const signals = withSignalStore(this);
     const _SIGNAL = this[OBJECT_SIGNAL] = entangleSignal(signals, this, OBJECT_SIGNAL, undefined);
     this[Context] = context;
@@ -2450,12 +2443,12 @@ class ManagedObject {
 
     // prettier-ignore
     const extensions = !context.legacy ? null : schema.CAUTION_MEGA_DANGER_ZONE_objectExtensions(field, null);
-    const proxy = new Proxy(this[SOURCE$1], {
+    const proxy = new Proxy(this[SOURCE], {
       ownKeys() {
-        return Object.keys(self[SOURCE$1]);
+        return Object.keys(self[SOURCE]);
       },
       has(target, prop) {
-        return prop in self[SOURCE$1];
+        return prop in self[SOURCE];
       },
       getOwnPropertyDescriptor(target, prop) {
         return {
@@ -2490,26 +2483,26 @@ class ManagedObject {
         if (_SIGNAL.isStale) {
           _SIGNAL.isStale = false;
           let newData = cache.getAttr(identifier, path);
-          if (newData && newData !== self[SOURCE$1]) {
+          if (newData && newData !== self[SOURCE]) {
             if (field.type) {
               const transform = schema.transformation(field);
               newData = transform.hydrate(newData, field.options ?? null, context.record);
             }
-            self[SOURCE$1] = Object.assign({}, newData); // Add type assertion for newData
+            self[SOURCE] = Object.assign({}, newData); // Add type assertion for newData
           }
         }
 
         // toJSON and extensions need to come after we update data if stale
         if (prop === 'toJSON') {
           return function () {
-            return structuredClone(self[SOURCE$1]);
+            return structuredClone(self[SOURCE]);
           };
         }
 
         // we always defer to data before extensions
-        if (prop in self[SOURCE$1]) {
+        if (prop in self[SOURCE]) {
           consumeInternalSignal(_SIGNAL);
-          return self[SOURCE$1][prop];
+          return self[SOURCE][prop];
         }
         if (isExtensionProp(extensions, prop)) {
           return performObjectExtensionGet(receiver, extensions, signals, prop);
@@ -2525,7 +2518,7 @@ class ManagedObject {
 
         // since objects function as dictionaries, we can't defer to schema/data before extensions
         // unless the prop is in the existing data.
-        if (!(prop in self[SOURCE$1]) && isExtensionProp(extensions, prop)) {
+        if (!(prop in self[SOURCE]) && isExtensionProp(extensions, prop)) {
           return performExtensionSet(receiver, extensions, signals, prop, value);
         }
         const reflect = Reflect.set(target, prop, value, receiver);
@@ -2533,10 +2526,10 @@ class ManagedObject {
           return false;
         }
         if (!field.type) {
-          cache.setAttr(identifier, path, self[SOURCE$1]);
+          cache.setAttr(identifier, path, self[SOURCE]);
         } else {
           const transform = schema.transformation(field);
-          const val = transform.serialize(self[SOURCE$1], field.options ?? null, context.record);
+          const val = transform.serialize(self[SOURCE], field.options ?? null, context.record);
           cache.setAttr(identifier, path, val);
         }
         _SIGNAL.isStale = true;
@@ -3101,7 +3094,7 @@ class ReactiveResource {
                   if (signal) {
                     const peeked = signal.value;
                     if (peeked) {
-                      notifyInternalSignal(peeked[ARRAY_SIGNAL]);
+                      notifyInternalSignal(peeked[Context].signal);
                     }
                   }
                   return;
@@ -3177,6 +3170,16 @@ class ReactiveResource {
               enumerable: true,
               configurable: true
             };
+          case '@hash':
+            return schemaForField.name ? {
+              writable: false,
+              enumerable: true,
+              configurable: true
+            } : {
+              writable: false,
+              enumerable: false,
+              configurable: false
+            };
           case '@local':
           case 'field':
           case 'attribute':
@@ -3916,41 +3919,7 @@ class InstanceCache {
 
     // TODO is this join still necessary?
     this.store._join(() => {
-      const record = this.__instances.record.get(identifier);
-      const cache = this.cache;
-      if (record) {
-        this.store.teardownRecord(record);
-        this.__instances.record.delete(identifier);
-        StoreMap.delete(record);
-        RecordCache.delete(record);
-        if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_INSTANCE_CACHE)) {
-          if (getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE || globalThis.getWarpDriveRuntimeConfig().debug.LOG_INSTANCE_CACHE) {
-            // eslint-disable-next-line no-console
-            console.log(`InstanceCache: destroyed record for ${String(identifier)}`);
-          }
-        }
-      }
-      if (cache) {
-        cache.unloadRecord(identifier);
-        StoreMap.delete(identifier);
-        if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_INSTANCE_CACHE)) {
-          if (getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE || globalThis.getWarpDriveRuntimeConfig().debug.LOG_INSTANCE_CACHE) {
-            // eslint-disable-next-line no-console
-            console.log(`InstanceCache: destroyed cache for ${String(identifier)}`);
-          }
-        }
-      } else {
-        this.disconnect(identifier);
-      }
-      this.store._requestCache._clearEntries(identifier);
-      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_INSTANCE_CACHE)) {
-        if (getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE || globalThis.getWarpDriveRuntimeConfig().debug.LOG_INSTANCE_CACHE) {
-          // eslint-disable-next-line no-console
-          console.log(`InstanceCache: unloaded RecordData for ${String(identifier)}`);
-          // eslint-disable-next-line no-console
-          console.groupEnd();
-        }
-      }
+      unloadRecord(this, identifier);
     });
   }
   clear(type) {
@@ -4029,7 +3998,7 @@ class InstanceCache {
 
     // TODO update resource cache if needed ?
     // TODO handle consequences of identifier merge for notifications
-    this.store.notifications.notify(identifier, 'identity');
+    this.store.notifications.notify(identifier, 'identity', null);
   }
 }
 function getNewRecord(instances, identifier, properties) {
@@ -4073,6 +4042,43 @@ function _clearCaches() {
   RecordCache.clear();
   StoreMap.clear();
 }
+function unloadRecord(instances, identifier) {
+  const record = instances.__instances.record.get(identifier);
+  const cache = instances.cache;
+  if (record) {
+    instances.store.teardownRecord(record);
+    instances.__instances.record.delete(identifier);
+    StoreMap.delete(record);
+    RecordCache.delete(record);
+    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_INSTANCE_CACHE)) {
+      if (getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE || globalThis.getWarpDriveRuntimeConfig().debug.LOG_INSTANCE_CACHE) {
+        // eslint-disable-next-line no-console
+        console.log(`InstanceCache: destroyed record for ${String(identifier)}`);
+      }
+    }
+  }
+  if (cache) {
+    cache.unloadRecord(identifier);
+    StoreMap.delete(identifier);
+    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_INSTANCE_CACHE)) {
+      if (getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE || globalThis.getWarpDriveRuntimeConfig().debug.LOG_INSTANCE_CACHE) {
+        // eslint-disable-next-line no-console
+        console.log(`InstanceCache: destroyed cache for ${String(identifier)}`);
+      }
+    }
+  } else {
+    instances.disconnect(identifier);
+  }
+  instances.store._requestCache._clearEntries(identifier);
+  if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_INSTANCE_CACHE)) {
+    if (getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE || globalThis.getWarpDriveRuntimeConfig().debug.LOG_INSTANCE_CACHE) {
+      // eslint-disable-next-line no-console
+      console.log(`InstanceCache: unloaded RecordData for ${String(identifier)}`);
+      // eslint-disable-next-line no-console
+      console.groupEnd();
+    }
+  }
+}
 
 /**
  * The CacheManager wraps a Cache enforcing that only
@@ -4716,6 +4722,11 @@ class NotificationManager {
    */
 
   subscribe(identifier, callback) {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected not to be destroyed`);
+      }
+    })(!this.isDestroyed) : {};
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
         throw new Error(`Expected to receive a stable Identifier to subscribe to`);
@@ -4761,6 +4772,9 @@ class NotificationManager {
    */
 
   notify(identifier, value, key) {
+    if (this.isDestroyed) {
+      return false;
+    }
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
         throw new Error(`Notify does not accept a key argument for the namespace '${value}'. Received key '${key || ''}'.`);
@@ -4775,14 +4789,14 @@ class NotificationManager {
       }
       return false;
     }
-    const hasSubscribers = Boolean(this._cache.get(identifier)?.length);
-    if (isCacheOperationValue(value) || hasSubscribers) {
+    const _hasSubscribers = hasSubscribers(this._cache, identifier, value);
+    if (_hasSubscribers) {
       let buffer = this._buffered.get(identifier);
       if (!buffer) {
         buffer = [];
         this._buffered.set(identifier, buffer);
       }
-      buffer.push([value, key]);
+      buffer.push([value, key || null]);
       if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_METRIC_COUNTS)) {
         if (getGlobalConfig().WarpDrive.debug.LOG_METRIC_COUNTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_METRIC_COUNTS) {
           count(`notify ${'type' in identifier ? identifier.type : '<document>'} ${value} ${key}`);
@@ -4807,7 +4821,7 @@ class NotificationManager {
         }
       }
     }
-    return hasSubscribers;
+    return _hasSubscribers;
   }
 
   /** @internal */
@@ -4834,43 +4848,17 @@ class NotificationManager {
     const buffered = this._buffered;
     if (buffered.size) {
       this._buffered = new Map();
-      buffered.forEach((states, identifier) => {
-        states.forEach(args => {
+      for (const [identifier, states] of buffered) {
+        for (let i = 0; i < states.length; i++) {
           // @ts-expect-error
-          this._flushNotification(identifier, args[0], args[1]);
-        });
-      });
+          _flushNotification(this._cache, identifier, states[i][0], states[i][1]);
+        }
+      }
     }
     this._hasFlush = false;
     this._onFlushCB?.();
     this._onFlushCB = undefined;
   }
-  _flushNotification(identifier, value, key) {
-    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_NOTIFICATIONS)) {
-      if (getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_NOTIFICATIONS) {
-        log('notify', '', `${'type' in identifier ? identifier.type : 'document'}`, identifier.lid, `${value}`, key || '');
-      }
-    }
-
-    // TODO for documents this will need to switch based on Identifier kind
-    if (isCacheOperationValue(value)) {
-      const callbackMap = this._cache.get(isDocumentIdentifier(identifier) ? 'document' : 'resource');
-      if (callbackMap) {
-        callbackMap.forEach(cb => {
-          cb(identifier, value);
-        });
-      }
-    }
-    const callbacks = this._cache.get(identifier);
-    if (!callbacks || !callbacks.length) {
-      return false;
-    }
-    callbacks.forEach(cb => {
-      // @ts-expect-error overload doesn't narrow within body
-      cb(identifier, value, key);
-    });
-    return true;
-  }
 
   /** @internal */
   destroy() {
@@ -4878,31 +4866,72 @@ class NotificationManager {
     this._cache.clear();
   }
 }
+function _flushNotification(cache, identifier, value, key) {
+  if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_NOTIFICATIONS)) {
+    if (getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_NOTIFICATIONS) {
+      log('notify', '', `${'type' in identifier ? identifier.type : 'document'}`, identifier.lid, `${value}`, key || '');
+    }
+  }
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/*
-  We redefine Proxy because the native Proxy type treats the `target` and
-  `receiver` as the same type incorrectly.
-
-  We ported this from Typescript's own Proxy types on 3/10/2024.
-*/
+  // TODO for documents this will need to switch based on Identifier kind
+  if (isCacheOperationValue(value)) {
+    const callbackMap = cache.get(isDocumentIdentifier(identifier) ? 'document' : 'resource');
+    if (callbackMap) {
+      callbackMap.forEach(cb => {
+        cb(identifier, value);
+      });
+    }
+  }
+  const callbacks = cache.get(identifier);
+  if (!callbacks || !callbacks.length) {
+    return false;
+  }
+  callbacks.forEach(cb => {
+    // @ts-expect-error overload doesn't narrow within body
+    cb(identifier, value, key);
+  });
+  return true;
+}
+function hasSubscribers(cache, identifier, value) {
+  const hasSubscriber = Boolean(cache.get(identifier)?.length);
+  if (hasSubscriber || !isCacheOperationValue(value)) {
+    return hasSubscriber;
+  }
+  const callbackMap = cache.get(isDocumentIdentifier(identifier) ? 'document' : 'resource');
+  return Boolean(callbackMap?.length);
+}
+function update() {
+  if (this.isUpdating) {
+    return this._updatingPromise;
+  }
+  this.isUpdating = true;
 
-const NativeProxy = Proxy;
+  // @ts-expect-error
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+  const updatingPromise = this._update();
+  void updatingPromise.finally(() => {
+    this._updatingPromise = null;
+    if (this.isDestroying || this.isDestroyed) {
+      return;
+    }
+    this.isUpdating = false;
+  });
+  this._updatingPromise = updatingPromise;
+  return updatingPromise;
+}
+function save() {
+  const context = this[Context];
+  const promise = Promise.all(this.map(record => context.store.saveRecord(record))).then(() => this);
+  return promise;
+}
 const ARRAY_GETTER_METHODS = new Set([Symbol.iterator, 'concat', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'flat', 'flatMap', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'map', 'reduce', 'reduceRight', 'slice', 'some', 'values']);
 const ARRAY_SETTER_METHODS = new Set(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
-const SYNC_PROPS = new Set(['[]', 'length', 'links', 'meta']);
 function isArrayGetter(prop) {
   return ARRAY_GETTER_METHODS.has(prop);
 }
 function isArraySetter(prop) {
   return ARRAY_SETTER_METHODS.has(prop);
 }
-function isSelfProp(self, prop) {
-  return prop in self;
-}
-const SOURCE = getOrSetGlobal('#source', Symbol('#source'));
-const MUTATE = getOrSetGlobal('#update', Symbol('#update'));
-const IS_COLLECTION = getOrSetGlobal('IS_COLLECTION', Symbol.for('Collection'));
 function convertToInt(prop) {
   if (typeof prop === 'symbol') return null;
   const num = Number(prop);
@@ -4933,388 +4962,30 @@ function safeForEach(instance, arr, store, callback, target) {
   return instance;
 }
 
-/**
-  A record array is an array that contains records of a certain type (or modelName).
-  The record array materializes records as needed when they are retrieved for the first
-  time. You should not create record arrays yourself. Instead, an instance of
-  `RecordArray` or its subclasses will be returned by your application's store
-  in response to queries.
-
-  This class should not be imported and instantiated by consuming applications.
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/*
+  We redefine Proxy because the native Proxy type treats the `target` and
+  `receiver` as the same type incorrectly.
 
-  @class RecordArray
-  @public
+  We ported this from Typescript's own Proxy types on 3/10/2024.
 */
 
+const NativeProxy = Proxy;
+const IS_COLLECTION = getOrSetGlobal('IS_COLLECTION', Symbol.for('Collection'));
+function isContextProp(prop) {
+  return prop === 'destroy' || prop === 'isDestroying' || prop === 'isDestroyed';
+}
 // these are "internally" mutable, they should not be mutated by consumers
 // though this is not currently enforced.
 //
 // all of these should become gated by field-type as they shouldn't be available
 // on request results or non-legacy relationships.
-const MUTABLE_PROPS = ['_updatingPromise', 'isDestroying', 'isDestroyed', 'query', 'isUpdating', 'isLoaded', 'meta', 'links', 'isAsync', 'isPolymorphic', 'identifier', 'cache', '_inverseIsAsync', 'key', 'DEPRECATED_CLASS_NAME'];
-class IdentifierArray {
-  /**
-    The flag to signal a `RecordArray` is currently loading data.
-    Example
-    ```javascript
-    let people = store.peekAll('person');
-    people.isUpdating; // false
-    people.update();
-    people.isUpdating; // true
-    ```
-    @property isUpdating
-    @public
-    @type Boolean
-  */
-
-  isLoaded = true;
-  isDestroying = false;
-  isDestroyed = false;
-  _updatingPromise = null;
-  identifier;
-
-  /**
-    The store that created this record array.
-     @property store
-    @private
-    @type Store
-    */
-
-  destroy(clear) {
-    this.isDestroying = !clear;
-    // changing the reference breaks the Proxy
-    // this[SOURCE] = [];
-    this[SOURCE].length = 0;
-    notifyInternalSignal(this[ARRAY_SIGNAL]);
-    this.isDestroyed = !clear;
-  }
-  constructor(options) {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this;
-    this.modelName = options.type;
-    this.store = options.store;
-    this._manager = options.manager;
-    this.identifier = options.identifier || null;
-    this[SOURCE] = options.identifiers;
-    this[IS_COLLECTION] = true;
-
-    // we attach the signal storage to the class
-    // so that its easier to find debugging.
-    const signals = withSignalStore(this);
-    const store = options.store;
-    const boundFns = new Map();
-    const PrivateState = {
-      links: options.links || null,
-      meta: options.meta || null
-    };
-    let transaction = false;
-
-    // when a mutation occurs
-    // we track all mutations within the call
-    // and forward them as one
-    let _SIGNAL = null;
-    const extensions = options.field && this.store.schema.CAUTION_MEGA_DANGER_ZONE_arrayExtensions ? this.store.schema.CAUTION_MEGA_DANGER_ZONE_arrayExtensions(options.field) : null;
-    const proxy = new NativeProxy(this[SOURCE], {
-      get(target, prop, receiver) {
-        const index = convertToInt(prop);
-        if (_SIGNAL.isStale && (index !== null || SYNC_PROPS.has(prop) || isArrayGetter(prop))) {
-          options.manager._syncArray(receiver);
-          _SIGNAL.isStale = false;
-        }
-        if (index !== null) {
-          const identifier = target[index];
-          if (!transaction) {
-            consumeInternalSignal(_SIGNAL);
-          }
-          return identifier && store._instanceCache.getRecord(identifier);
-        }
-        if (prop === ARRAY_SIGNAL) {
-          return _SIGNAL;
-        }
-        if (prop === 'length') {
-          return consumeInternalSignal(_SIGNAL), target.length;
-        }
-        if (prop === 'meta') return consumeInternalSignal(_SIGNAL), PrivateState.meta;
-        if (prop === 'links') return consumeInternalSignal(_SIGNAL), PrivateState.links;
-        if (prop === '[]') return consumeInternalSignal(_SIGNAL), receiver;
-        if (isArrayGetter(prop)) {
-          let fn = boundFns.get(prop);
-          if (fn === undefined) {
-            if (prop === 'forEach') {
-              fn = function () {
-                consumeInternalSignal(_SIGNAL);
-                transaction = true;
-                const result = safeForEach(receiver, target, store, arguments[0], arguments[1]);
-                transaction = false;
-                return result;
-              };
-            } else {
-              fn = function () {
-                consumeInternalSignal(_SIGNAL);
-                // array functions must run through Reflect to work properly
-                // binding via other means will not work.
-                transaction = true;
-                const result = Reflect.apply(target[prop], receiver, arguments);
-                transaction = false;
-                return result;
-              };
-            }
-            boundFns.set(prop, fn);
-          }
-          return fn;
-        }
-        if (isArraySetter(prop)) {
-          let fn = boundFns.get(prop);
-          if (fn === undefined) {
-            fn = function () {
-              // array functions must run through Reflect to work properly
-              // binding via other means will not work.
-              if (!options.allowMutation) {
-                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                  if (!test) {
-                    throw new Error(`Mutating this array of records via ${String(prop)} is not allowed.`);
-                  }
-                })(options.allowMutation) : {};
-                return;
-              }
-              const args = Array.prototype.slice.call(arguments);
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-                if (!test) {
-                  throw new Error(`Cannot start a new array transaction while a previous transaction is underway`);
-                }
-              })(!transaction) : {};
-              transaction = true;
-              const result = options[MUTATE](target, receiver, prop, args, _SIGNAL);
-              transaction = false;
-              return result;
-            };
-            boundFns.set(prop, fn);
-          }
-          return fn;
-        }
-        if (isSelfProp(self, prop)) {
-          if (prop === SOURCE) {
-            return self[prop];
-          }
-          let fn = boundFns.get(prop);
-          if (fn) return fn;
-          const outcome = self[prop];
-          if (typeof outcome === 'function') {
-            fn = function () {
-              consumeInternalSignal(_SIGNAL);
-              // array functions must run through Reflect to work properly
-              // binding via other means will not work.
-              return Reflect.apply(outcome, receiver, arguments);
-            };
-            boundFns.set(prop, fn);
-            return fn;
-          }
-          return consumeInternalSignal(_SIGNAL), outcome;
-        }
-        if (isExtensionProp(extensions, prop)) {
-          return performArrayExtensionGet(receiver, extensions, signals, prop, _SIGNAL, boundFns, v => void (transaction = v));
-        }
-        return target[prop];
-      },
-      // FIXME: Should this get a generic like get above?
-      set(target, prop, value, receiver) {
-        if (!options.allowMutation && !MUTABLE_PROPS.includes(prop)) {
-          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-            if (!test) {
-              throw new Error(`Mutating ${String(prop)} on this Array is not allowed.`);
-            }
-          })(options.allowMutation) : {};
-          return false;
-        }
-        if (prop === 'length') {
-          if (!transaction && value === 0) {
-            transaction = true;
-            options[MUTATE](target, receiver, 'length 0', [], _SIGNAL);
-            transaction = false;
-            return true;
-          } else if (transaction) {
-            return Reflect.set(target, prop, value);
-          } else {
-            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-              {
-                throw new Error(`unexpected length set`);
-              }
-            })() : {};
-          }
-        }
-        if (prop === 'links') {
-          PrivateState.links = value || null;
-          return true;
-        }
-        if (prop === 'meta') {
-          PrivateState.meta = value || null;
-          return true;
-        }
-        if (isExtensionProp(extensions, prop)) {
-          return performExtensionSet(receiver, extensions, signals, prop, value);
-        }
-        const index = convertToInt(prop);
-
-        // we do not allow "holey" arrays and so if the index is
-        // greater than length then we will disallow setting it.
-        // however, there is a special case for "unshift" with more than
-        // one item being inserted since current items will be moved to the
-        // new indices first.
-        // we "loosely" detect this by just checking whether we are in
-        // a transaction.
-        if (index === null || index > target.length) {
-          if (index !== null && transaction) {
-            const identifier = recordIdentifierFor(value);
-            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-              if (!test) {
-                throw new Error(`Cannot set index ${index} past the end of the array.`);
-              }
-            })(isStableIdentifier(identifier)) : {};
-            target[index] = identifier;
-            return true;
-          } else if (isSelfProp(self, prop)) {
-            // @ts-expect-error not all properties are indeces and we can't safely cast
-            self[prop] = value;
-            return true;
-          }
-          return false;
-        }
-        const original = target[index];
-        const newIdentifier = extractIdentifierFromRecord$2(value);
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`Expected a record`);
-          }
-        })(isStableIdentifier(newIdentifier)) : {};
-        // We generate "transactions" whenever a setter method on the array
-        // is called and might bulk update multiple array cells. Fundamentally,
-        // all array operations decompose into individual cell replacements.
-        // e.g. a push is really a "replace cell at next index with new value"
-        // or a splice is "shift all values left/right by X and set out of new
-        // bounds cells to undefined"
-        //
-        // so, if we are in a transaction, then this is not a user generated change
-        // but one generated by a setter method. In this case we want to only apply
-        // the change to the target array and not call the MUTATE method.
-        // If there is no transaction though, then this means the user themselves has
-        // directly changed the value of a specific index and we need to thus generate
-        // a mutation for that change.
-        // e.g. "arr.push(newVal)" is handled by a "addToRelatedRecords" mutation within
-        // a transaction.
-        // while "arr[arr.length] = newVal;" is handled by this replace cell code path.
-        if (!transaction) {
-          options[MUTATE](target, receiver, 'replace cell', [index, original, newIdentifier], _SIGNAL);
-        } else {
-          target[index] = newIdentifier;
-        }
-        return true;
-      },
-      deleteProperty(target, prop) {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`Deleting keys on managed arrays is disallowed`);
-          }
-        })(transaction) : {};
-        if (!transaction) {
-          return false;
-        }
-        return Reflect.deleteProperty(target, prop);
-      },
-      getPrototypeOf() {
-        return Array.prototype;
-      }
-    });
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      Object.defineProperty(this, '__SHOW_ME_THE_DATA_(debug mode only)__', {
-        enumerable: false,
-        configurable: true,
-        get() {
-          return proxy.slice();
-        }
-      });
-    }
-
-    // we entangle the signal on the returned proxy since that is
-    // the object that other code will be interfacing with.
-    _SIGNAL = entangleSignal(signals, proxy, ARRAY_SIGNAL, undefined);
-    return proxy;
-  }
-
-  /**
-    Used to get the latest version of all of the records in this array
-    from the adapter.
-     Example
-     ```javascript
-    let people = store.peekAll('person');
-    people.isUpdating; // false
-     people.update().then(function() {
-      people.isUpdating; // false
-    });
-     people.isUpdating; // true
-    ```
-     @public
-  */
-  update() {
-    if (this.isUpdating) {
-      return this._updatingPromise;
-    }
-    this.isUpdating = true;
-    const updatingPromise = this._update();
-    void updatingPromise.finally(() => {
-      this._updatingPromise = null;
-      if (this.isDestroying || this.isDestroyed) {
-        return;
-      }
-      this.isUpdating = false;
-    });
-    this._updatingPromise = updatingPromise;
-    return updatingPromise;
-  }
-
-  /*
-    Update this Array and return a promise which resolves once the update
-    is finished.
-   */
-  _update() {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`_update cannot be used with this array`);
-      }
-    })(this.modelName) : {};
-    // @ts-expect-error typescript is unable to handle the complexity of
-    //   T = unknown, modelName = string
-    //   T extends TypedRecordInstance, modelName = TypeFromInstance<T>
-    // both being valid options to pass through here.
-    return this.store.findAll(this.modelName, {
-      reload: true
-    });
-  }
-
-  // TODO deprecate
-  /**
-    Saves all of the records in the `RecordArray`.
-     Example
-     ```javascript
-    let messages = store.peekAll('message');
-    messages.forEach(function(message) {
-      message.hasBeenSeen = true;
-    });
-    messages.save();
-    ```
-     @public
-    @return {Promise<IdentifierArray>} promise
-  */
-  save() {
-    const promise = Promise.all(this.map(record => this.store.saveRecord(record))).then(() => this);
-    return promise;
-  }
-}
-
+const MUTABLE_PROPS = ['_updatingPromise', 'isDestroying', 'isDestroyed', 'query', 'isUpdating', 'isLoaded', 'meta', 'links', 'isAsync', 'isPolymorphic', 'identifier', 'cache', 'key', 'DEPRECATED_CLASS_NAME'];
 // this will error if someone tries to call
 // A(identifierArray) since it is not configurable
 // which is preferable to the `meta` override we used
 // before which required importing all of Ember
-const desc = {
+const ARR_BRACKET_DESC = {
   enumerable: true,
   configurable: false,
   get: function () {
@@ -5325,58 +4996,312 @@ const desc = {
     }
   }
 };
-// compat(desc);
-Object.defineProperty(IdentifierArray.prototype, '[]', desc);
-defineSignal(IdentifierArray.prototype, 'isUpdating', false);
-class Collection extends IdentifierArray {
-  query = null;
-  constructor(options) {
-    super(options);
-    this.query = options.query || null;
-    this.isLoaded = options.isLoaded || false;
-  }
-  _update() {
-    const {
-      store,
-      query
-    } = this;
+const IS_UPDATING_DESC = createSignalDescriptor('isUpdating', false);
+const ArrayHandler = {
+  getOwnPropertyDescriptor(target, prop) {
+    if (prop === '[]') {
+      // proxies do not allow you to report a descriptor as non-configurable
+      // if there is no descriptor or the underlying descriptor is configurable
+      const underlying = Reflect.getOwnPropertyDescriptor(target, prop);
+      if (!underlying) {
+        Object.defineProperty(target, prop, ARR_BRACKET_DESC);
+      }
+      return ARR_BRACKET_DESC;
+    }
+    if (prop === 'isUpdating') {
+      return IS_UPDATING_DESC;
+    }
+    return Reflect.getOwnPropertyDescriptor(target, prop);
+  },
+  get(target, prop, receiver) {
+    const CONTEXT = target[Context];
+
+    // we place this prop first as it needs initialized
+    // prior to the signal check below
+    if (prop === Signals) return CONTEXT.signals;
+    const index = convertToInt(prop);
+    if (
+    // prettier-ignore
+    CONTEXT.signal.isStale && (index !== null || prop === 'length' || prop === '[]' || CONTEXT.data && prop in CONTEXT.data || isArrayGetter(prop))) {
+      CONTEXT.manager._syncArray(receiver);
+      CONTEXT.signal.isStale = false;
+    }
+    if (index !== null) {
+      const identifier = target[index];
+      if (!CONTEXT.transaction) {
+        consumeInternalSignal(CONTEXT.signal);
+      }
+      return identifier && CONTEXT.store._instanceCache.getRecord(identifier);
+    }
+    if (prop === 'length') return consumeInternalSignal(CONTEXT.signal), target.length;
+    if (prop === '[]') return consumeInternalSignal(CONTEXT.signal), receiver;
+    // TODO move this to ?? so its only on subclasses
+    if (prop === 'isUpdating') return IS_UPDATING_DESC.get.call(receiver);
+    if (prop === IS_COLLECTION) return true;
+    if (prop === Context) return CONTEXT;
+    if (isContextProp(prop)) {
+      return CONTEXT[prop];
+    }
+    if (CONTEXT.data && prop in CONTEXT.data) {
+      // all props in data are reactive props.
+      return consumeInternalSignal(CONTEXT.signal), CONTEXT.data[prop];
+    }
+    if (isArrayGetter(prop)) {
+      let fn = CONTEXT.boundFns.get(prop);
+      if (fn === undefined) {
+        if (prop === 'forEach') {
+          fn = function () {
+            consumeInternalSignal(CONTEXT.signal);
+            CONTEXT.transaction = true;
+            const result = safeForEach(receiver, target, CONTEXT.store, arguments[0], arguments[1]);
+            CONTEXT.transaction = false;
+            return result;
+          };
+        } else {
+          fn = function () {
+            consumeInternalSignal(CONTEXT.signal);
+            // array functions must run through Reflect to work properly
+            // binding via other means will not work.
+            CONTEXT.transaction = true;
+            const result = Reflect.apply(target[prop], receiver, arguments);
+            CONTEXT.transaction = false;
+            return result;
+          };
+        }
+        CONTEXT.boundFns.set(prop, fn);
+      }
+      return fn;
+    }
+    if (isArraySetter(prop)) {
+      let fn = CONTEXT.boundFns.get(prop);
+      if (fn === undefined) {
+        fn = function () {
+          // array functions must run through Reflect to work properly
+          // binding via other means will not work.
+          if (!CONTEXT.editable) {
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              if (!test) {
+                throw new Error(`Mutating this array of records via ${String(prop)} is not allowed.`);
+              }
+            })(CONTEXT.editable) : {};
+            return;
+          }
+          const args = Array.prototype.slice.call(arguments);
+          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+            if (!test) {
+              throw new Error(`Cannot start a new array transaction while a previous transaction is underway`);
+            }
+          })(!CONTEXT.transaction) : {};
+          CONTEXT.transaction = true;
+          const result = CONTEXT.mutate(target, receiver, prop, args, CONTEXT.signal);
+          CONTEXT.transaction = false;
+          return result;
+        };
+        CONTEXT.boundFns.set(prop, fn);
+      }
+      return fn;
+    }
+    if (CONTEXT.features && prop in CONTEXT.features) {
+      let fn = CONTEXT.boundFns.get(prop);
+      if (fn) return fn;
+
+      // @ts-expect-error
+      const outcome = CONTEXT.features[prop];
+      if (typeof outcome === 'function') {
+        fn = function () {
+          consumeInternalSignal(CONTEXT.signal);
+          // array functions must run through Reflect to work properly
+          // binding via other means will not work.
+          return Reflect.apply(outcome, receiver, arguments);
+        };
+        CONTEXT.boundFns.set(prop, fn);
+        return fn;
+      }
+      return consumeInternalSignal(CONTEXT.signal), outcome;
+    }
+    if (isExtensionProp(CONTEXT.extensions, prop)) {
+      return performArrayExtensionGet(receiver, CONTEXT.extensions, CONTEXT.signals, prop, CONTEXT.signal, CONTEXT.boundFns, v => void (CONTEXT.transaction = v));
+    }
+    return target[prop];
+  },
+  set(target, prop, value, receiver) {
+    const CONTEXT = target[Context];
+    if (prop === Signals) {
+      CONTEXT.signals = value;
+      return true;
+    }
+    if (!CONTEXT.editable && !MUTABLE_PROPS.includes(prop)) {
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Mutating ${String(prop)} on this Array is not allowed.`);
+        }
+      })(CONTEXT.editable) : {};
+      return false;
+    }
+    if (prop === 'length') {
+      if (!CONTEXT.transaction && value === 0) {
+        CONTEXT.transaction = true;
+        CONTEXT.mutate(target, receiver, 'length 0', [], CONTEXT.signal);
+        CONTEXT.transaction = false;
+        return true;
+      } else if (CONTEXT.transaction) {
+        return Reflect.set(target, prop, value);
+      } else {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`unexpected length set`);
+          }
+        })() : {};
+      }
+    }
+    if (isContextProp(prop)) {
+      // @ts-expect-error
+      CONTEXT[prop] = value;
+      return true;
+    }
+    if (CONTEXT.data && prop in CONTEXT.data) {
+      CONTEXT.data[prop] = value || null;
+      return true;
+    }
 
-    // TODO save options from initial request?
+    // TODO move this to subclass
+    if (prop === 'isUpdating') {
+      IS_UPDATING_DESC.set.call(receiver, value);
+      return true;
+    }
+    if (isExtensionProp(CONTEXT.extensions, prop)) {
+      return performExtensionSet(receiver, CONTEXT.extensions, CONTEXT.signals, prop, value);
+    }
+    const index = convertToInt(prop);
+
+    // we do not allow "holey" arrays and so if the index is
+    // greater than length then we will disallow setting it.
+    // however, there is a special case for "unshift" with more than
+    // one item being inserted since current items will be moved to the
+    // new indices first.
+    // we "loosely" detect this by just checking whether we are in
+    // a transaction.
+    if (index === null || index > target.length) {
+      if (index !== null && CONTEXT.transaction) {
+        const identifier = recordIdentifierFor(value);
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`Cannot set index ${index} past the end of the array.`);
+          }
+        })(isStableIdentifier(identifier)) : {};
+        target[index] = identifier;
+        return true;
+      } else if (CONTEXT.features && prop in CONTEXT.features) {
+        CONTEXT.features[prop] = value;
+        return true;
+      }
+      return false;
+    }
+    const original = target[index];
+    const newIdentifier = extractIdentifierFromRecord$2(value);
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
-        throw new Error(`update cannot be used with this array`);
-      }
-    })(this.modelName) : {};
+        throw new Error(`Expected a record`);
+      }
+    })(newIdentifier && isStableIdentifier(newIdentifier)) : {};
+    // We generate "transactions" whenever a setter method on the array
+    // is called and might bulk update multiple array cells. Fundamentally,
+    // all array operations decompose into individual cell replacements.
+    // e.g. a push is really a "replace cell at next index with new value"
+    // or a splice is "shift all values left/right by X and set out of new
+    // bounds cells to undefined"
+    //
+    // so, if we are in a transaction, then this is not a user generated change
+    // but one generated by a setter method. In this case we want to only apply
+    // the change to the target array and not call the MUTATE method.
+    // If there is no transaction though, then this means the user themselves has
+    // directly changed the value of a specific index and we need to thus generate
+    // a mutation for that change.
+    // e.g. "arr.push(newVal)" is handled by a "addToRelatedRecords" mutation within
+    // a transaction.
+    // while "arr[arr.length] = newVal;" is handled by this replace cell code path.
+    if (!CONTEXT.transaction) {
+      CONTEXT.mutate(target, receiver, 'replace cell', [index, original, newIdentifier], CONTEXT.signal);
+    } else {
+      target[index] = newIdentifier;
+    }
+    return true;
+  },
+  deleteProperty(target, prop) {
+    const CONTEXT = target[Context];
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
-        throw new Error(`update cannot be used with no query`);
+        throw new Error(`Deleting keys on managed arrays is disallowed`);
       }
-    })(query) : {};
-    // @ts-expect-error typescript is unable to handle the complexity of
-    //   T = unknown, modelName = string
-    //   T extends TypedRecordInstance, modelName = TypeFromInstance<T>
-    // both being valid options to pass through here.
-    const promise = store.query(this.modelName, query, {
-      _recordArray: this
-    });
-    return promise;
+    })(CONTEXT.transaction) : {};
+    if (!CONTEXT.transaction) {
+      return false;
+    }
+    return Reflect.deleteProperty(target, prop);
+  },
+  getPrototypeOf() {
+    return Array.prototype;
   }
-  destroy(clear) {
-    super.destroy(clear);
-    this._manager._managed.delete(this);
-    this._manager._pending.delete(this);
+};
+const ILLEGAL_MUTATION = () => {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    {
+      throw new Error(`ILLEGAL OPERATION: This ReactiveResourceArray is immutable`);
+    }
+  })() : {};
+};
+function createReactiveResourceArray(options) {
+  const TARGET = options.source;
+  const context = {
+    store: options.store,
+    manager: options.manager,
+    editable: options.editable,
+    source: options.source,
+    data: options.data,
+    features: options.features,
+    extensions: options.extensions,
+    options: options.options,
+    destroy: options.destroy || destroy,
+    mutate: options.mutate || ILLEGAL_MUTATION,
+    signals: null,
+    signal: null,
+    isDestroying: false,
+    isDestroyed: false,
+    transaction: false,
+    boundFns: new Map()
+  };
+  TARGET[Context] = context;
+  const proxy = new NativeProxy(TARGET, ArrayHandler);
+  if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    Object.defineProperty(TARGET, '__SHOW_ME_THE_DATA_(debug mode only)__', {
+      enumerable: false,
+      configurable: true,
+      get() {
+        return proxy.slice();
+      }
+    });
   }
+
+  // we entangle the signal on the returned proxy since that is
+  // the object that other code will be interfacing with.
+  // when a mutation occurs
+  // we track all mutations within the call
+  // and forward them as one
+  withSignalStore(proxy);
+  context.signal = createInternalSignal(context.signals, proxy, ARRAY_SIGNAL, undefined);
+  return proxy;
 }
-// trick the proxy "in" check
-Collection.prototype.query = null;
 
 // Ensure instanceof works correctly
 // Object.setPrototypeOf(IdentifierArray.prototype, Array.prototype);
 
-function assertRecordPassedToHasMany$1(record) {
+function extractIdentifierFromRecord$2(record) {
+  if (!record) {
+    return null;
+  }
   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}`);
+      throw new Error(`All elements of a ReactiveResourceArray must be instances of a ReactiveResource, you passed $${typeof record}`);
     }
   })(function () {
     try {
@@ -5386,14 +5311,155 @@ function assertRecordPassedToHasMany$1(record) {
       return false;
     }
   }()) : {};
-}
-function extractIdentifierFromRecord$2(record) {
-  if (!record) {
-    return null;
-  }
-  assertRecordPassedToHasMany$1(record);
   return recordIdentifierFor(record);
 }
+function destroy(clear) {
+  const context = this[Context];
+  this.isDestroying = !clear;
+  // changing the reference breaks the Proxy
+  // this[SOURCE] = [];
+  context.source.length = 0;
+  notifyInternalSignal(context.signal);
+  this.isDestroyed = !clear;
+}
+function createRequestCollection(config) {
+  return createReactiveResourceArray({
+    store: config.store,
+    manager: config.manager,
+    editable: false,
+    source: config.source,
+    data: null,
+    features: null,
+    extensions: null,
+    options: config.options,
+    destroy: null,
+    mutate: null
+  });
+}
+
+/**
+ * The options for {@link createLegacyLiveArray}
+ *
+ * @internal
+ */
+/**
+ * Creates a {@link LegacyLiveArray}
+ *
+ * @internal
+ */
+function createLegacyLiveArray(options) {
+  return createReactiveResourceArray({
+    store: options.store,
+    manager: options.manager,
+    editable: false,
+    source: options.source,
+    data: null,
+    features: {
+      modelName: options.type,
+      update,
+      _update: _updateLiveArray,
+      save,
+      DEPRECATED_CLASS_NAME: 'LiveArray',
+      isUpdating: false,
+      isLoaded: true,
+      _updatingPromise: null
+    },
+    extensions: null,
+    options: null,
+    destroy: null,
+    mutate: null
+  });
+}
+function _updateLiveArray() {
+  const context = this[Context];
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`_update cannot be used with this array`);
+    }
+  })(this.modelName) : {};
+  // @ts-expect-error typescript is unable to handle the complexity of
+  //   T = unknown, modelName = string
+  //   T extends TypedRecordInstance, modelName = TypeFromInstance<T>
+  // both being valid options to pass through here.
+  return context.store.findAll(this.modelName, {
+    reload: true
+  });
+}
+
+/**
+ * The options for {@link createLegacyQueryArray}
+ *
+ * See also {@link LegacyLiveArrayCreateOptions} which
+ * this extends.
+ *
+ * @internal
+ */
+/**
+ * Creates a {@link LegacyQueryArray}
+ *
+ * Options: {@link LegacyQueryArrayCreateOptions}
+ *
+ * @internal
+ */
+function createLegacyQueryArray(options) {
+  return createReactiveResourceArray({
+    store: options.store,
+    manager: options.manager,
+    editable: false,
+    source: options.source,
+    data: {
+      links: options.links,
+      meta: options.meta
+    },
+    features: {
+      query: options.query,
+      modelName: options.type,
+      update,
+      _update: _updateCollection,
+      save,
+      DEPRECATED_CLASS_NAME: 'LegacyQueryArray',
+      isUpdating: false,
+      isLoaded: options.isLoaded,
+      _updatingPromise: null
+    },
+    extensions: null,
+    options: null,
+    destroy: destroyCollection,
+    mutate: null
+  });
+}
+function _updateCollection() {
+  const context = this[Context];
+  const {
+    query
+  } = this;
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`update cannot be used with this array`);
+    }
+  })(this.modelName) : {};
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`update cannot be used with no query`);
+    }
+  })(query) : {};
+  // @ts-expect-error typescript is unable to handle the complexity of
+  //   T = unknown, modelName = string
+  //   T extends TypedRecordInstance, modelName = TypeFromInstance<T>
+  // both being valid options to pass through here.
+  const promise = context.store.query(this.modelName, query, {
+    _recordArray: this
+  });
+  return promise;
+}
+function destroyCollection(clear) {
+  destroy.call(this, clear ?? false);
+  const {
+    manager
+  } = this[Context];
+  manager._managed.delete(this);
+  manager._pending.delete(this);
+}
 const FAKE_ARR = getOrSetGlobal('FAKE_ARR', {});
 const SLICE_BATCH_SIZE = 4761;
 /**
@@ -5429,7 +5495,6 @@ const SLICE_BATCH_SIZE = 4761;
  * Sincerely,
  *   - runspired (Chris Thoburn) 08/21/2022
  *
- * @function fastPush
  * @internal
  * @param target the array to push into
  * @param source the items to push into target
@@ -5447,6 +5512,54 @@ function fastPush(target, source) {
   @internal
 */
 class RecordArrayManager {
+  /**
+   *
+   */
+
+  /**
+   * LiveArray (peekAll/findAll) array instances
+   * keyed by their ResourceType.
+   */
+
+  /**
+   *
+   */
+
+  /**
+   * Buffered changes to apply keyed by the array to
+   * which to apply them to.
+   */
+
+  /**
+   * An inverse map from StableRecordIdentifier to the list
+   * of arrays it can be found in, useful for fast updates
+   * when state changes to a resource occur.
+   */
+
+  /**
+   * When we do not yet have a LiveArray, this keeps track of
+   * the added/removed identifiers to enable us to more efficiently
+   * produce the LiveArray later.
+   *
+   * It's possible that using a Set and only storing additions instead of
+   * additions and deletes would be more efficient.
+   */
+
+  /**
+   * KeyedArrays are arrays associated to a specific RequestKey.
+   */
+
+  /**
+   * The visibility set tracks whether a given identifier should
+   * be shown in RecordArrays. It is used to dedupe added/removed
+   * and state change events.
+   *
+   * As a Map, it grows to be very large - there may be ways to
+   * reduce its size by instead migrating to it functioning as
+   * an exclusion list. Any entry not in the list would be considered
+   * visible.
+   */
+
   constructor(options) {
     this.store = options.store;
     this.isDestroying = false;
@@ -5459,12 +5572,15 @@ class RecordArrayManager {
     this._identifiers = new Map();
     this._set = new Map();
     this._visibilitySet = new Map();
-    this._subscription = this.store.notifications.subscribe('document', (identifier, type) => {
+    this._documentSubscription = this.store.notifications.subscribe('document', (identifier, type) => {
       if (type === 'updated' && this._keyedArrays.has(identifier.lid)) {
         const array = this._keyedArrays.get(identifier.lid);
         this.dirtyArray(array, 0, true);
       }
     });
+    this._subscribeToResourceChanges();
+  }
+  _subscribeToResourceChanges() {
     this._subscription = this.store.notifications.subscribe('resource', (identifier, type) => {
       const schema = this.store.schema.resource?.(identifier);
       // If we are a polaris mode schema
@@ -5488,8 +5604,8 @@ class RecordArrayManager {
   }
   _syncArray(array) {
     const pending = this._pending.get(array);
-    const isRequestArray = isCollection(array);
-    if (!isRequestArray && !pending || this.isDestroying || this.isDestroyed) {
+    const isLegacyQuery = isLegacyQueryArray(array);
+    if (isLegacyQuery && !pending || this.isDestroying || this.isDestroyed) {
       return;
     }
 
@@ -5500,16 +5616,18 @@ class RecordArrayManager {
     }
 
     // then pull new state if required
-    if (isRequestArray) {
-      const signal = array[ARRAY_SIGNAL];
+    if (!isLegacyQuery && !isLegacyLiveArray(array)) {
+      const context = array[Context];
+      const signal = context.signal;
+      const identifier = context.options.requestKey;
 
       // we only need to rebuild the array from cache if a full sync is required
       // due to notification that the cache has changed
       if (signal.value === 'cache-sync') {
-        const doc = this.store.cache.peek(array.identifier);
+        const doc = this.store.cache.peek(identifier);
         macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
           if (!test) {
-            throw new Error(`Expected to find a document for ${array.identifier.lid} but found none`);
+            throw new Error(`Expected to find a document for ${identifier.lid} but found none`);
           }
         })(doc) : {};
         const data = !('data' in doc) || !Array.isArray(doc.data) ? [] : doc.data;
@@ -5544,12 +5662,11 @@ class RecordArrayManager {
       this._staged.delete(type);
     }
     if (!array) {
-      array = new IdentifierArray({
-        type,
-        identifiers,
+      array = createLegacyLiveArray({
         store: this.store,
-        allowMutation: false,
-        manager: this
+        manager: this,
+        source: identifiers,
+        type
       });
       this._live.set(type, array);
       this._set.set(array, new Set(identifiers));
@@ -5557,37 +5674,55 @@ class RecordArrayManager {
     return array;
   }
   getCollection(config) {
-    if (config.identifier && this._keyedArrays.has(config.identifier.lid)) {
-      return this._keyedArrays.get(config.identifier.lid);
-    }
-    const options = {
-      type: config.type,
-      identifier: config.identifier || null,
-      links: config.doc?.links || null,
-      meta: config.doc?.meta || null,
-      query: config.query || null,
-      identifiers: config.identifiers || [],
-      isLoaded: !!config.identifiers?.length,
-      allowMutation: false,
-      store: this.store,
-      manager: this
-    };
-    const array = new Collection(options);
-    this._managed.add(array);
-    this._set.set(array, new Set(options.identifiers || []));
-    if (config.identifier) {
-      this._keyedArrays.set(config.identifier.lid, array);
+    if ('requestKey' in config && this._keyedArrays.has(config.requestKey.lid)) {
+      return this._keyedArrays.get(config.requestKey.lid);
     }
-    if (config.identifiers) {
-      associate(this._identifiers, array, config.identifiers);
+    let array = null;
+    if ('requestKey' in config) {
+      const options = {
+        store: this.store,
+        manager: this,
+        source: config.source,
+        options: {
+          requestKey: config.requestKey
+        }
+      };
+      array = createRequestCollection(options);
+      this._keyedArrays.set(config.requestKey.lid, array);
+      this._set.set(array, new Set(config.source));
+      associate(this._identifiers, array, config.source);
+    } else if ('query' in config) {
+      const options = {
+        store: this.store,
+        manager: this,
+        source: [],
+        type: config.type,
+        query: config.query,
+        isLoaded: false,
+        links: null,
+        meta: null
+      };
+      array = createLegacyQueryArray(options);
+      this._set.set(array, new Set());
+    } else {
+      const options = {
+        store: this.store,
+        manager: this,
+        source: config.source,
+        options: null
+      };
+      array = createRequestCollection(options);
+      this._set.set(array, new Set(config.source));
+      associate(this._identifiers, array, config.source);
     }
+    this._managed.add(array);
     return array;
   }
   dirtyArray(array, delta, shouldSyncFromCache) {
     if (array === FAKE_ARR) {
       return;
     }
-    const signal = array[ARRAY_SIGNAL];
+    const signal = array[Context].signal;
     if (!signal.isStale || delta > 0) {
       notifyInternalSignal(signal);
 
@@ -5619,7 +5754,7 @@ class RecordArrayManager {
 
     // during unloadAll we can ignore removes since we've already
     // cleared the array.
-    if (liveArray && liveArray[SOURCE].length === 0 && isRemove) {
+    if (liveArray && liveArray[Context].source.length === 0 && isRemove) {
       const pendingLive = allPending.get(liveArray);
       if (!pendingLive || pendingLive.size === 0) {
         return pending;
@@ -5646,7 +5781,7 @@ class RecordArrayManager {
   }
   populateManagedArray(array, identifiers, payload) {
     this._pending.delete(array);
-    const source = array[SOURCE];
+    const source = array[Context].source;
     macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
       if (!test) {
         throw new Error(`The new state of the collection should not be using the same array reference as the original state.`);
@@ -5656,12 +5791,12 @@ class RecordArrayManager {
     source.length = 0;
     fastPush(source, identifiers);
     this._set.set(array, new Set(identifiers));
-    if (!isCollection(array)) {
-      notifyInternalSignal(array[ARRAY_SIGNAL]);
+    if (isLegacyQueryArray(array)) {
+      notifyInternalSignal(array[Context].signal);
       array.meta = payload?.meta || null;
       array.links = payload?.links || null;
+      array.isLoaded = true;
     }
-    array.isLoaded = true;
     disassociate(this._identifiers, array, old);
     associate(this._identifiers, array, identifiers);
   }
@@ -5707,21 +5842,34 @@ class RecordArrayManager {
       this.identifierRemoved(identifier);
     }
   }
+  pause() {
+    this.store.notifications.unsubscribe(this._subscription);
+  }
+  resume() {
+    this._subscribeToResourceChanges();
+  }
   clear(isClear = true) {
-    this._live.forEach(array => array.destroy(isClear));
-    this._managed.forEach(array => array.destroy(isClear));
+    for (const array of this._live.values()) {
+      array.destroy(isClear);
+    }
+    for (const array of this._managed.values()) {
+      array.destroy(isClear);
+    }
     this._managed.clear();
     this._identifiers.clear();
     this._pending.clear();
-    this._set.forEach(set => set.clear());
+    for (const set of this._set.values()) {
+      set.clear();
+    }
     this._visibilitySet.clear();
   }
   destroy() {
     this.isDestroying = true;
     this.clear(false);
     this._live.clear();
-    this.isDestroyed = true;
     this.store.notifications.unsubscribe(this._subscription);
+    this.store.notifications.unsubscribe(this._documentSubscription);
+    this.isDestroyed = true;
   }
 }
 function associate(ArraysCache, array, identifiers) {
@@ -5747,7 +5895,7 @@ function disassociateIdentifier(ArraysCache, array, identifier) {
   }
 }
 function sync(array, changes, arraySet) {
-  const state = array[SOURCE];
+  const state = array[Context].source;
   const adds = [];
   const removes = [];
   changes.forEach((value, key) => {
@@ -5793,8 +5941,13 @@ function sync(array, changes, arraySet) {
     */
   }
 }
-function isCollection(array) {
-  return array.identifier !== null;
+function isLegacyQueryArray(array) {
+  const context = array[Context];
+  return context.features !== null && context.features.DEPRECATED_CLASS_NAME === 'LegacyQueryArray';
+}
+function isLegacyLiveArray(array) {
+  const context = array[Context];
+  return context.features !== null && context.features.DEPRECATED_CLASS_NAME === 'LiveArray';
 }
 const Touching = getOrSetGlobal('Touching', Symbol('touching'));
 const RequestPromise = getOrSetGlobal('RequestPromise', Symbol('promise'));
@@ -6846,7 +6999,9 @@ class Store extends BaseClass {
       }
     })(!type || typeof type === 'string') : {};
     this._join(() => {
+      this._enableAsyncFlush = true;
       if (type === undefined) {
+        this.recordArrayManager.pause();
         // destroy the graph before unloadAll
         // since then we avoid churning relationships
         // during unload
@@ -6856,6 +7011,11 @@ class Store extends BaseClass {
       } else {
         this._instanceCache.clear(normalizeModelName(type));
       }
+      this._enableAsyncFlush = null;
+      this.notifications._flush();
+      if (type === undefined) {
+        this.recordArrayManager.resume();
+      }
     });
   }
 
@@ -7058,7 +7218,7 @@ class Store extends BaseClass {
     this.notifications.destroy();
     this.recordArrayManager.destroy();
     this.identifierCache.destroy();
-    this.unloadAll();
+    this._instanceCache.clear();
     this.isDestroyed = true;
   }
 
@@ -8027,7 +8187,7 @@ const CacheHandler = {
       if (identifier) {
         promise = promise.finally(() => {
           DEDUPE.delete(identifier);
-          store.notifications.notify(identifier, 'state');
+          store.notifications.notify(identifier, 'state', null);
         });
         DEDUPE.set(identifier, {
           priority: {
@@ -8035,7 +8195,7 @@ const CacheHandler = {
           },
           promise
         });
-        store.notifications.notify(identifier, 'state');
+        store.notifications.notify(identifier, 'state', null);
       }
       return promise;
     }
@@ -8048,7 +8208,7 @@ const CacheHandler = {
       if (identifier && !activeRequest) {
         promise = promise.finally(() => {
           DEDUPE.delete(identifier);
-          store.notifications.notify(identifier, 'state');
+          store.notifications.notify(identifier, 'state', null);
         });
         DEDUPE.set(identifier, {
           priority: {
@@ -8056,7 +8216,7 @@ const CacheHandler = {
           },
           promise
         });
-        store.notifications.notify(identifier, 'state');
+        store.notifications.notify(identifier, 'state', null);
       }
       store.requestManager._pending.set(context.id, promise);
     }
@@ -8287,6 +8447,47 @@ function constructResource(type, id, lid) {
     };
   }
 }
+
+/**
+ * The options for {@link createLegacyManyArray}
+ *
+ * @internal
+ */
+/**
+ * Creates a {@link LegacyManyArray}
+ *
+ * @internal
+ */
+function createLegacyManyArray(options) {
+  const extensions = options.store.schema.CAUTION_MEGA_DANGER_ZONE_arrayExtensions ? options.store.schema.CAUTION_MEGA_DANGER_ZONE_arrayExtensions(options.field) : null;
+  return createReactiveResourceArray({
+    store: options.store,
+    manager: options.manager,
+    editable: options.editable,
+    source: options.source,
+    data: {
+      links: options.links,
+      meta: options.meta
+    },
+    features: {
+      modelName: options.type,
+      save,
+      DEPRECATED_CLASS_NAME: 'ManyArray',
+      isLoaded: options.isLoaded,
+      isAsync: options.isAsync,
+      isPolymorphic: options.isPolymorphic,
+      identifier: options.identifier,
+      key: options.field.name,
+      reload,
+      createRecord,
+      notify
+    },
+    extensions,
+    options: null,
+    destroy: destroyLegacyManyArray,
+    mutate: _MUTATE
+  });
+}
 function _MUTATE(target, receiver, prop, args, _SIGNAL) {
   const collection = receiver;
   switch (prop) {
@@ -8409,7 +8610,7 @@ function _MUTATE(target, receiver, prop, args, _SIGNAL) {
         const [start, deleteCount, ...adds] = args;
 
         // detect a full replace
-        if (start === 0 && deleteCount === collection[SOURCE].length) {
+        if (start === 0 && deleteCount === collection[Context].source.length) {
           const newValues = extractIdentifiersFromRecords(adds);
           assertNoDuplicates(collection, 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)) {
@@ -8483,190 +8684,37 @@ function _MUTATE(target, receiver, prop, args, _SIGNAL) {
       })() : {};
   }
 }
-/**
-  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:
-
-  ```js [app/models/post.js]
-  import Model, { hasMany } from '@ember-data/model';
-
-  export default class PostModel extends Model {
-    @hasMany('comment') comments;
-  }
-  ```
-
-  ```js [app/models/comment.js]
-  import { Model, belongsTo } from '@warp-drive/legacy/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 IdentifierArray {
-  /**
-    The loading state of this array
-     @property isLoaded
-    @type {Boolean}
-    @public
-    */
-
-  /**
-    `true` if the relationship is polymorphic, `false` otherwise.
-     @property isPolymorphic
-    @type {Boolean}
-    @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 notify() {
+  notifyInternalSignal(this[Context].signal);
+}
+function reload(options) {
+  const {
+    manager
+  } = this[Context];
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected the manager for ManyArray to implement reloadHasMany`);
     }
-    ```
-     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 meta
-    @type {Object | null}
-    @public
-    */
-
-  /**
-     * Retrieve the links for this relationship
-     *
-     @property links
-     @type {Object | null}
-     @public
-     */
-
-  constructor(options) {
-    options[MUTATE] = _MUTATE;
-    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;
-  }
-  notify() {
-    notifyInternalSignal(this[ARRAY_SIGNAL]);
-  }
-
-  /**
-    Reloads all of the records in the manyArray. If the manyArray
-    holds a relationship that was originally fetched using a links url
-    WarpDrive 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();
-    ```
-     @public
-  */
-  reload(options) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected the manager for ManyArray to implement reloadHasMany`);
-      }
-    })(typeof this._manager.reloadHasMany === 'function') : {};
-    // TODO this is odd, we don't ask the store for anything else like this?
-    return this._manager.reloadHasMany(this.key, options);
-  }
-
-  /**
-    Create a child record within the owner
-     @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;
-  }
-
-  /**
-    Saves all of the records in the `ManyArray`.
-     Note: this API can only be used in legacy mode with a configured Adapter.
-     Example
-     ```javascript
-    const { content: { data: inbox } } = await store.request(findRecord({ type: 'inbox', id: '1' }));
-     let messages = await inbox.messages;
-    messages.forEach((message) => {
-      message.isRead = true;
-    });
-    messages.save();
-    ```
-     @public
-    @return {PromiseArray} promise
-  */
-
-  /** @internal */
-  destroy() {
-    super.destroy(false);
-  }
+  })(typeof manager.reloadHasMany === 'function') : {};
+  // TODO this is odd, we don't ask the store for anything else like this?
+  return manager.reloadHasMany(this.key, options);
+}
+function createRecord(hash) {
+  const {
+    store
+  } = this[Context];
+  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;
+}
+function destroyLegacyManyArray() {
+  destroy.call(this, 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) {
@@ -8689,12 +8737,13 @@ function extractIdentifierFromRecord(recordOrPromiseRecord) {
   return recordIdentifierFor(recordOrPromiseRecord);
 }
 function assertNoDuplicates(collection, target, callback, reason) {
+  const identifier = collection[Context].features.identifier;
   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, {
+      deprecate(`${reason} This behavior is deprecated. Found duplicates for the following records within the new state provided to \`<${identifier.type}:${identifier.id || 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',
@@ -8704,62 +8753,75 @@ function assertNoDuplicates(collection, target, callback, reason) {
         }
       });
     } 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- ')}`);
+      throw new Error(`${reason} Found duplicates for the following records within the new state provided to \`<${identifier.type}:${identifier.id || 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) {
+  const identifier = collection[Context].features.identifier;
+
   // FIXME field needs to use sourceKey
   mutate(collection, {
     op: 'add',
-    record: collection.identifier,
+    record: identifier,
     field: collection.key,
     ...operationInfo
   }, _SIGNAL);
 }
 function mutateRemoveFromRelatedRecords(collection, operationInfo, _SIGNAL) {
+  const identifier = collection[Context].features.identifier;
+
   // FIXME field needs to use sourceKey
   mutate(collection, {
     op: 'remove',
-    record: collection.identifier,
+    record: identifier,
     field: collection.key,
     ...operationInfo
   }, _SIGNAL);
 }
 function mutateReplaceRelatedRecord(collection, operationInfo, _SIGNAL) {
+  const identifier = collection[Context].features.identifier;
+
   // FIXME field needs to use sourceKey
   mutate(collection, {
     op: 'replaceRelatedRecord',
-    record: collection.identifier,
+    record: identifier,
     field: collection.key,
     ...operationInfo
   }, _SIGNAL);
 }
 function mutateReplaceRelatedRecords(collection, value, _SIGNAL) {
+  const identifier = collection[Context].features.identifier;
+
   // FIXME field needs to use sourceKey
   mutate(collection, {
     op: 'replaceRelatedRecords',
-    record: collection.identifier,
+    record: identifier,
     field: collection.key,
     value
   }, _SIGNAL);
 }
 function mutateSortRelatedRecords(collection, value, _SIGNAL) {
+  const identifier = collection[Context].features.identifier;
+
   // FIXME field needs to use sourceKey
   mutate(collection, {
     op: 'sortRelatedRecords',
-    record: collection.identifier,
+    record: identifier,
     field: collection.key,
     value
   }, _SIGNAL);
 }
 function mutate(collection, mutation, _SIGNAL) {
+  const {
+    manager
+  } = collection[Context];
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
     if (!test) {
       throw new Error(`Expected the manager for ManyArray to implement mutate`);
     }
-  })(typeof collection._manager.mutate === 'function') : {};
-  collection._manager.mutate(mutation);
+  })(typeof manager.mutate === 'function') : {};
+  manager.mutate(mutation);
   notifyInternalSignal(_SIGNAL);
 }
 const PromiseCache = new WeakMap();
@@ -9941,4 +10003,4 @@ function getRequestState(future) {
   }
   return state;
 }
-export { peekInternalSignal as A, withSignalStore as B, CacheHandler as C, DISPOSE as D, notifyInternalSignal as E, consumeInternalSignal as F, getOrCreateInternalSignal as G, ReactiveResource as H, IdentifierArray as I, isNonIdentityCacheableField as J, getFieldCacheKeyStrict as K, setIdentifierGenerationMethod as L, MUTATE as M, setIdentifierUpdateMethod as N, setIdentifierForgetMethod as O, setIdentifierResetMethod as P, setKeyInfoForResource as Q, RecordArrayManager as R, Store as S, _clearCaches as _, isDocumentIdentifier as a, coerceId as b, constructResource as c, Collection as d, ensureStringId as e, SOURCE as f, fastPush as g, setRecordIdentifier as h, isStableIdentifier as i, StoreMap as j, RelatedCollection as k, log as l, logGroup as m, normalizeModelName as n, getPromiseState as o, createRequestSubscription as p, getRequestState as q, recordIdentifierFor as r, storeFor as s, memoized as t, gate as u, entangleSignal as v, defineSignal as w, defineGate as x, defineNonEnumerableSignal as y, Signals as z };
+export { notifyInternalSignal as A, consumeInternalSignal as B, CacheHandler as C, DISPOSE as D, getOrCreateInternalSignal as E, ReactiveResource as F, isNonIdentityCacheableField as G, getFieldCacheKeyStrict as H, setIdentifierGenerationMethod as I, setIdentifierUpdateMethod as J, setIdentifierForgetMethod as K, setIdentifierResetMethod as L, setKeyInfoForResource as M, RecordArrayManager as R, Store as S, _clearCaches as _, isDocumentIdentifier as a, coerceId as b, constructResource as c, setRecordIdentifier as d, ensureStringId as e, fastPush as f, StoreMap as g, createLegacyManyArray as h, isStableIdentifier as i, logGroup as j, getPromiseState as k, log as l, createRequestSubscription as m, normalizeModelName as n, getRequestState as o, memoized as p, gate as q, recordIdentifierFor as r, storeFor as s, entangleSignal as t, defineSignal as u, defineGate as v, defineNonEnumerableSignal as w, Signals as x, peekInternalSignal as y, withSignalStore as z };