@warp-drive/core 5.6.0-alpha.14 → 5.6.0-alpha.17

package/dist/{request-state-DgwTEXLU.js → request-state-CjLph1LP.js}

@@ -1,11 +1,11 @@
+import { withBrand, EnableHydration, SkipCache } from './types/request.js';
 import { deprecate, warn } from '@ember/debug';
 import { macroCondition, getGlobalConfig, dependencySatisfies, importSync } from '@embroider/macros';
-import { withBrand, EnableHydration, SkipCache } from './types/request.js';
 import { setLogging, getRuntimeConfig } from './types/runtime.js';
 import { getOrSetGlobal, peekTransient, setTransient } from './types/-private.js';
-import { a as createSignal, b as consumeSignal, n as notifySignal, c as createMemo, d as willSyncFlushWatchers, A as ARRAY_SIGNAL } from "./configure-BgaZESRo.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 { a as createSignal, b as consumeSignal, n as notifySignal, c as createMemo, d as willSyncFlushWatchers, A as ARRAY_SIGNAL } from "./configure-B48bFHOl.js";
 import { g as getPromiseResult, s as setPromiseResult } from "./context-COmAnXUQ.js";
 function coerceId(id) {
   if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_NON_STRICT_ID)) {
@@ -393,7 +393,7 @@ if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
 }
 
 /**
- * Each instance of {Store} receives a unique instance of a IdentifierCache.
+ * Each instance of {@link Store} receives a unique instance of a IdentifierCache.
  *
  * This cache is responsible for assigning or retrieving the unique identify
  * for arbitrary resource data encountered by the store. Data representing
@@ -402,10 +402,12 @@ if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
  *
  * It can be configured by consuming applications.
  *
- * @class IdentifierCache
-   @public
+ * @hideconstructor
+ * @public
  */
 class IdentifierCache {
+  /** @internal */
+
   constructor() {
     // we cache the user configuredGenerationMethod at init because it must
     // be configured prior and is not allowed to be changed
@@ -435,6 +437,8 @@ class IdentifierCache {
   __configureMerge(method) {
     this._merge = method || defaultMergeMethod;
   }
+
+  /** @internal */
   upgradeIdentifier(resource) {
     return this._getRecordIdentifier(resource, 2);
   }
@@ -524,8 +528,6 @@ class IdentifierCache {
    * useful for the "create" case when we need to see if
    * we are accidentally overwritting something
    *
-   * @param resource
-   * @return {StableRecordIdentifier | undefined}
    * @private
    */
   peekRecordIdentifier(resource) {
@@ -535,9 +537,7 @@ class IdentifierCache {
   /**
     Returns the DocumentIdentifier for the given Request, creates one if it does not yet exist.
     Returns `null` if the request does not have a `cacheKey` or `url`.
-     @param request
-    @return {StableDocumentIdentifier | null}
-    @public
+     @public
   */
   getOrCreateDocumentIdentifier(request) {
     let cacheKey = request.cacheOptions?.key;
@@ -568,9 +568,7 @@ class IdentifierCache {
     - return an object with an `lid` that is stable (repeated calls with the same
       `id` + `type` or `lid` will return the same `lid` value)
     - this referential stability of the object itself is guaranteed
-     @param resource
-    @return {StableRecordIdentifier}
-    @public
+     @public
   */
   getOrCreateRecordIdentifier(resource) {
     return this._getRecordIdentifier(resource, 1);
@@ -582,9 +580,7 @@ class IdentifierCache {
    potentially does not have an `id`.
     Delegates generation to the user supplied `GenerateMethod` if one has been provided
    with the signature `generateMethod({ type }, 'record')`.
-    @param data
-   @return {StableRecordIdentifier}
-   @public
+    @public
   */
   createIdentifierForNewRecord(data) {
     const newLid = this._generate(data, 'record');
@@ -625,10 +621,7 @@ class IdentifierCache {
      If a merge occurs, it is possible the returned identifier does not match the originally
     provided identifier. In this case the abandoned identifier will go through the usual
     `forgetRecordIdentifier` codepaths.
-     @param identifierObject
-    @param data
-    @return {StableRecordIdentifier}
-    @public
+     @public
   */
   updateRecordIdentifier(identifierObject, data) {
     let identifier = this.getOrCreateRecordIdentifier(identifierObject);
@@ -741,8 +734,7 @@ class IdentifierCache {
     Useful when a record has been deleted and the deletion has been persisted and
    we do not care about the record anymore. Especially useful when an `id` of a
    deleted record might be reused later for a new record.
-    @param identifierObject
-   @public
+    @public
   */
   forgetRecordIdentifier(identifierObject) {
     const identifier = this.getOrCreateRecordIdentifier(identifierObject);
@@ -776,6 +768,8 @@ class IdentifierCache {
       }
     }
   }
+
+  /** @internal */
   destroy() {
     NEW_IDENTIFIERS.clear();
     this._cache.documents.forEach(identifier => {
@@ -1568,13 +1562,12 @@ function _log(scope, prefix, subScop1, subScop2, subScop3, subScop4) {
    A `RecordReference` is a low-level API that allows users and
    addon authors to perform meta-operations on a record.
 
-   @class RecordReference
+   @hideconstructor
    @public
 */
 class RecordReference {
   // unsubscribe token given to us by the notification manager
-  ___token;
-  ___identifier;
+
   constructor(store, identifier) {
     this.store = store;
     this.___identifier = identifier;
@@ -1584,6 +1577,8 @@ class RecordReference {
       }
     });
   }
+
+  /** @internal */
   destroy() {
     this.store.notifications.unsubscribe(this.___token);
   }
@@ -1601,7 +1596,6 @@ class RecordReference {
       userRef.id(); // '1'
      ```
      @public
-     @return {String} The id of the record.
   */
   id() {
     // eslint-disable-next-line @typescript-eslint/no-unused-expressions
@@ -1619,7 +1613,6 @@ class RecordReference {
       userRef.identifier(); // '1'
      ```
      @public
-     @return {String} The identifier of the record.
   */
   identifier() {
     return this.___identifier;
@@ -1635,7 +1628,6 @@ class RecordReference {
       userRef.remoteType(); // 'identity'
      ```
       @public
-     @return {String} 'identity'
   */
   remoteType() {
     return 'identity';
@@ -1690,7 +1682,6 @@ class RecordReference {
       userRef.value(); // user
      ```
      @public
-     @return {Model} the record for this RecordReference
   */
   value() {
     return this.store.peekRecord(this.___identifier);
@@ -1706,7 +1697,6 @@ class RecordReference {
      userRef.load().then(...)
      ```
      @public
-     @return {Promise<record>} the record for this RecordReference
   */
   load() {
     const id = this.id();
@@ -1730,7 +1720,6 @@ class RecordReference {
      userRef.reload().then(...)
      ```
      @public
-     @return {Promise<record>} the record for this RecordReference
   */
   reload() {
     const id = this.id();
@@ -2977,10 +2966,22 @@ function _unsubscribe(token, cache) {
  * This Feature is what allows WarpDrive to create subscriptions that
  * work with any framework or change-notification system.
  *
- * @class NotificationManager
+ * @hideconstructor
  * @public
  */
 class NotificationManager {
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
   constructor(store) {
     this.store = store;
     this.isDestroyed = false;
@@ -3048,7 +3049,6 @@ class NotificationManager {
    * remove a previous subscription
    *
    * @public
-   * @param {UnsubscribeToken} token
    */
   unsubscribe(token) {
     if (!this.isDestroyed) {
@@ -3059,10 +3059,6 @@ class NotificationManager {
   /**
    * Custom Caches and Application Code should not call this method directly.
    *
-   * @param identifier
-   * @param value
-   * @param key
-   * @return {Boolean} whether a notification was delivered to any subscribers
    * @private
    */
 
@@ -3115,6 +3111,8 @@ class NotificationManager {
     }
     return hasSubscribers;
   }
+
+  /** @internal */
   _onNextFlush(cb) {
     this._onFlushCB = cb;
   }
@@ -3132,6 +3130,8 @@ class NotificationManager {
     this._flush();
     return true;
   }
+
+  /** @internal */
   _flush() {
     const buffered = this._buffered;
     if (buffered.size) {
@@ -3173,11 +3173,149 @@ class NotificationManager {
     });
     return true;
   }
+
+  /** @internal */
   destroy() {
     this.isDestroyed = true;
     this._cache.clear();
   }
 }
+function isExtensionProp(extensions, prop) {
+  return Boolean(extensions && typeof prop !== 'number' && extensions.has(prop));
+}
+function performObjectExtensionGet(receiver, extensions, signals, prop) {
+  const desc = extensions.get(prop);
+  switch (desc.kind) {
+    case 'method':
+      {
+        return desc.fn;
+      }
+    case 'readonly-value':
+      {
+        return desc.value;
+      }
+    case 'mutable-value':
+      {
+        const signal = getOrCreateInternalSignal(signals, receiver, prop, desc.value);
+        // we don't consume this signal, since its not a true local.
+        return signal.value;
+      }
+    case 'readonly-field':
+    case 'mutable-field':
+      {
+        return desc.get.call(receiver);
+      }
+    case 'writeonly-field':
+      {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Cannot get extended field ${String(prop)} as its definition has only a setter`);
+          }
+        })() : {};
+        return undefined;
+      }
+    default:
+      {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Unhandled extension kind ${desc.kind}`);
+          }
+        })() : {};
+        return undefined;
+      }
+  }
+}
+function performExtensionSet(receiver, extensions, signals, prop, value) {
+  const desc = extensions.get(prop);
+  switch (desc.kind) {
+    case 'method':
+    case 'readonly-value':
+    case 'readonly-field':
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        {
+          throw new Error(`Cannot set extension field ${String(prop)} as it is a ${desc.kind}`);
+        }
+      })() : {};
+      return false;
+    case 'mutable-value':
+      {
+        const signal = getOrCreateInternalSignal(signals, receiver, prop, desc.value);
+        if (signal.value !== value) {
+          // we don't notify this signal, since its not a true local.
+          signal.value = value;
+        }
+        return true;
+      }
+    case 'writeonly-field':
+    case 'mutable-field':
+      {
+        desc.set.call(receiver, value);
+        return true;
+      }
+    default:
+      {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Unhandled extension kind ${desc.kind}`);
+          }
+        })() : {};
+        return false;
+      }
+  }
+}
+function performArrayExtensionGet(receiver, extensions, signals, prop, _SIGNAL, boundFns, transaction) {
+  const desc = extensions.get(prop);
+  switch (desc.kind) {
+    case 'method':
+      {
+        let fn = boundFns.get(prop);
+        if (fn === undefined) {
+          fn = function () {
+            consumeInternalSignal(_SIGNAL);
+            transaction(true);
+            const result = Reflect.apply(desc.fn, receiver, arguments);
+            transaction(false);
+            return result;
+          };
+          boundFns.set(prop, fn);
+        }
+        return fn;
+      }
+    case 'mutable-field':
+    case 'readonly-field':
+      {
+        return desc.get.call(receiver);
+      }
+    case 'readonly-value':
+      {
+        return desc.value;
+      }
+    case 'mutable-value':
+      {
+        const signal = getOrCreateInternalSignal(signals, receiver, prop, desc.value);
+        // we don't consume this signal, since its not a true local.
+        return signal.value;
+      }
+    case 'writeonly-field':
+      {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Cannot get extended field ${String(prop)} as its definition has only a setter`);
+          }
+        })() : {};
+        return undefined;
+      }
+    default:
+      {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Unhandled extension kind ${desc.kind}`);
+          }
+        })() : {};
+        return undefined;
+      }
+  }
+}
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /*
@@ -3246,6 +3384,12 @@ function safeForEach(instance, arr, store, callback, target) {
   @public
 */
 
+// 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.
@@ -3307,6 +3451,7 @@ class IdentifierArray {
     // 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);
@@ -3377,7 +3522,7 @@ class IdentifierArray {
                 }
               })(!transaction) : {};
               transaction = true;
-              const result = self[MUTATE](target, receiver, prop, args, _SIGNAL);
+              const result = options[MUTATE](target, receiver, prop, args, _SIGNAL);
               transaction = false;
               return result;
             };
@@ -3404,14 +3549,25 @@ class IdentifierArray {
           }
           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;
-            self[MUTATE](target, receiver, 'length 0', [], _SIGNAL);
+            options[MUTATE](target, receiver, 'length 0', [], _SIGNAL);
             transaction = false;
             return true;
           } else if (transaction) {
@@ -3432,6 +3588,9 @@ class IdentifierArray {
           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
@@ -3458,14 +3617,6 @@ class IdentifierArray {
           }
           return false;
         }
-        if (!options.allowMutation) {
-          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-            if (!test) {
-              throw new Error(`Mutating ${String(prop)} on this Array is not allowed.`);
-            }
-          })(options.allowMutation) : {};
-          return false;
-        }
         const original = target[index];
         const newIdentifier = extractIdentifierFromRecord$2(value);
         macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -3490,7 +3641,7 @@ class IdentifierArray {
         // a transaction.
         // while "arr[arr.length] = newVal;" is handled by this replace cell code path.
         if (!transaction) {
-          self[MUTATE](target, receiver, 'replace cell', [index, original, newIdentifier], _SIGNAL);
+          options[MUTATE](target, receiver, 'replace cell', [index, original, newIdentifier], _SIGNAL);
         } else {
           target[index] = newIdentifier;
         }
@@ -4088,10 +4239,11 @@ function hasRecordIdentifier(op) {
  * The RequestStateService is used to track the state of requests
  * for fetching or updating known resource identifies that are inflight.
  *
- * @class RequestStateService
+ * @hideconstructor
  * @public
  */
 class RequestStateService {
+  /** @internal */
   _pending = new Map();
   _done = new Map();
   _subscriptions = new Map();
@@ -4100,9 +4252,11 @@ class RequestStateService {
   constructor(store) {
     this._store = store;
   }
+  /** @internal */
   _clearEntries(identifier) {
     this._done.delete(identifier);
   }
+  /** @internal */
   _enqueue(promise, queryRequest) {
     const query = queryRequest.data[0];
     if (hasRecordIdentifier(query)) {
@@ -4456,6 +4610,8 @@ if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_METRIC_COUNTS))
  *
  */
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 const EmptyClass = class {
   // eslint-disable-next-line @typescript-eslint/no-useless-constructor
@@ -6331,7 +6487,202 @@ function extractIdentifierFromRecord$1(recordOrPromiseRecord) {
   const extract = recordIdentifierFor;
   return extract(recordOrPromiseRecord);
 }
+function _MUTATE(target, receiver, prop, args, _SIGNAL) {
+  const collection = receiver;
+  switch (prop) {
+    case 'length 0':
+      {
+        Reflect.set(target, 'length', 0);
+        mutateReplaceRelatedRecords(collection, [], _SIGNAL);
+        return true;
+      }
+    case 'replace cell':
+      {
+        const [index, prior, value] = args;
+        target[index] = value;
+        mutateReplaceRelatedRecord(collection, {
+          value,
+          prior,
+          index
+        }, _SIGNAL);
+        return true;
+      }
+    case 'push':
+      {
+        const newValues = extractIdentifiersFromRecords(args);
+        assertNoDuplicates(collection, target, currentState => currentState.push(...newValues), `Cannot push duplicates to a hasMany's state.`);
+        if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
+          // dedupe
+          const seen = new Set(target);
+          const unique = new Set();
+          args.forEach(item => {
+            const identifier = recordIdentifierFor(item);
+            if (!seen.has(identifier)) {
+              seen.add(identifier);
+              unique.add(item);
+            }
+          });
+          const newArgs = Array.from(unique);
+          const result = Reflect.apply(target[prop], receiver, newArgs);
+          if (newArgs.length) {
+            mutateAddToRelatedRecords(collection, {
+              value: extractIdentifiersFromRecords(newArgs)
+            }, _SIGNAL);
+          }
+          return result;
+        }
+
+        // else, no dedupe, error on duplicates
+        const result = Reflect.apply(target[prop], receiver, args);
+        if (newValues.length) {
+          mutateAddToRelatedRecords(collection, {
+            value: newValues
+          }, _SIGNAL);
+        }
+        return result;
+      }
+    case 'pop':
+      {
+        const result = Reflect.apply(target[prop], receiver, args);
+        if (result) {
+          mutateRemoveFromRelatedRecords(collection, {
+            value: recordIdentifierFor(result)
+          }, _SIGNAL);
+        }
+        return result;
+      }
+    case 'unshift':
+      {
+        const newValues = extractIdentifiersFromRecords(args);
+        assertNoDuplicates(collection, target, currentState => currentState.unshift(...newValues), `Cannot unshift duplicates to a hasMany's state.`);
+        if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
+          // dedupe
+          const seen = new Set(target);
+          const unique = new Set();
+          args.forEach(item => {
+            const identifier = recordIdentifierFor(item);
+            if (!seen.has(identifier)) {
+              seen.add(identifier);
+              unique.add(item);
+            }
+          });
+          const newArgs = Array.from(unique);
+          const result = Reflect.apply(target[prop], receiver, newArgs);
+          if (newArgs.length) {
+            mutateAddToRelatedRecords(collection, {
+              value: extractIdentifiersFromRecords(newArgs),
+              index: 0
+            }, _SIGNAL);
+          }
+          return result;
+        }
+
+        // else, no dedupe, error on duplicates
+        const result = Reflect.apply(target[prop], receiver, args);
+        if (newValues.length) {
+          mutateAddToRelatedRecords(collection, {
+            value: newValues,
+            index: 0
+          }, _SIGNAL);
+        }
+        return result;
+      }
+    case 'shift':
+      {
+        const result = Reflect.apply(target[prop], receiver, args);
+        if (result) {
+          mutateRemoveFromRelatedRecords(collection, {
+            value: recordIdentifierFor(result),
+            index: 0
+          }, _SIGNAL);
+        }
+        return result;
+      }
+    case 'sort':
+      {
+        const result = Reflect.apply(target[prop], receiver, args);
+        mutateSortRelatedRecords(collection, result.map(recordIdentifierFor), _SIGNAL);
+        return result;
+      }
+    case 'splice':
+      {
+        const [start, deleteCount, ...adds] = args;
+
+        // detect a full replace
+        if (start === 0 && deleteCount === collection[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)) {
+            // dedupe
+            const current = new Set(adds);
+            const unique = Array.from(current);
+            const newArgs = [start, deleteCount].concat(unique);
+            const result = Reflect.apply(target[prop], receiver, newArgs);
+            mutateReplaceRelatedRecords(collection, extractIdentifiersFromRecords(unique), _SIGNAL);
+            return result;
+          }
+
+          // else, no dedupe, error on duplicates
+          const result = Reflect.apply(target[prop], receiver, args);
+          mutateReplaceRelatedRecords(collection, newValues, _SIGNAL);
+          return result;
+        }
+        const newValues = extractIdentifiersFromRecords(adds);
+        assertNoDuplicates(collection, target, currentState => currentState.splice(start, deleteCount, ...newValues), `Cannot splice a hasMany's state with a new state that contains duplicates.`);
+        if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
+          // dedupe
+          const currentState = target.slice();
+          currentState.splice(start, deleteCount);
+          const seen = new Set(currentState);
+          const unique = [];
+          adds.forEach(item => {
+            const identifier = recordIdentifierFor(item);
+            if (!seen.has(identifier)) {
+              seen.add(identifier);
+              unique.push(item);
+            }
+          });
+          const newArgs = [start, deleteCount, ...unique];
+          const result = Reflect.apply(target[prop], receiver, newArgs);
+          if (deleteCount > 0) {
+            mutateRemoveFromRelatedRecords(collection, {
+              value: result.map(recordIdentifierFor),
+              index: start
+            }, _SIGNAL);
+          }
+          if (unique.length > 0) {
+            mutateAddToRelatedRecords(collection, {
+              value: extractIdentifiersFromRecords(unique),
+              index: start
+            }, _SIGNAL);
+          }
+          return result;
+        }
 
+        // else, no dedupe, error on duplicates
+        const result = Reflect.apply(target[prop], receiver, args);
+        if (deleteCount > 0) {
+          mutateRemoveFromRelatedRecords(collection, {
+            value: result.map(recordIdentifierFor),
+            index: start
+          }, _SIGNAL);
+        }
+        if (newValues.length > 0) {
+          mutateAddToRelatedRecords(collection, {
+            value: newValues,
+            index: start
+          }, _SIGNAL);
+        }
+        return result;
+      }
+    default:
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        {
+          throw new Error(`unable to convert ${prop} into a transaction that updates the cache state for this record array`);
+        }
+      })() : {};
+  }
+}
 /**
   A `ManyArray` is a `MutableArray` that represents the contents of a has-many
   relationship.
@@ -6430,6 +6781,7 @@ class RelatedCollection extends IdentifierArray {
      */
 
   constructor(options) {
+    options[MUTATE] = _MUTATE;
     super(options);
     this.isLoaded = options.isLoaded || false;
     this.isAsync = options.isAsync || false;
@@ -6437,204 +6789,9 @@ class RelatedCollection extends IdentifierArray {
     this.identifier = options.identifier;
     this.key = options.key;
   }
-  [MUTATE](target, receiver, prop, args, _SIGNAL) {
-    switch (prop) {
-      case 'length 0':
-        {
-          Reflect.set(target, 'length', 0);
-          mutateReplaceRelatedRecords(this, [], _SIGNAL);
-          return true;
-        }
-      case 'replace cell':
-        {
-          const [index, prior, value] = args;
-          target[index] = value;
-          mutateReplaceRelatedRecord(this, {
-            value,
-            prior,
-            index
-          }, _SIGNAL);
-          return true;
-        }
-      case 'push':
-        {
-          const newValues = extractIdentifiersFromRecords(args);
-          assertNoDuplicates(this, target, currentState => currentState.push(...newValues), `Cannot push duplicates to a hasMany's state.`);
-          if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
-            // dedupe
-            const seen = new Set(target);
-            const unique = new Set();
-            args.forEach(item => {
-              const identifier = recordIdentifierFor(item);
-              if (!seen.has(identifier)) {
-                seen.add(identifier);
-                unique.add(item);
-              }
-            });
-            const newArgs = Array.from(unique);
-            const result = Reflect.apply(target[prop], receiver, newArgs);
-            if (newArgs.length) {
-              mutateAddToRelatedRecords(this, {
-                value: extractIdentifiersFromRecords(newArgs)
-              }, _SIGNAL);
-            }
-            return result;
-          }
-
-          // else, no dedupe, error on duplicates
-          const result = Reflect.apply(target[prop], receiver, args);
-          if (newValues.length) {
-            mutateAddToRelatedRecords(this, {
-              value: newValues
-            }, _SIGNAL);
-          }
-          return result;
-        }
-      case 'pop':
-        {
-          const result = Reflect.apply(target[prop], receiver, args);
-          if (result) {
-            mutateRemoveFromRelatedRecords(this, {
-              value: recordIdentifierFor(result)
-            }, _SIGNAL);
-          }
-          return result;
-        }
-      case 'unshift':
-        {
-          const newValues = extractIdentifiersFromRecords(args);
-          assertNoDuplicates(this, target, currentState => currentState.unshift(...newValues), `Cannot unshift duplicates to a hasMany's state.`);
-          if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
-            // dedupe
-            const seen = new Set(target);
-            const unique = new Set();
-            args.forEach(item => {
-              const identifier = recordIdentifierFor(item);
-              if (!seen.has(identifier)) {
-                seen.add(identifier);
-                unique.add(item);
-              }
-            });
-            const newArgs = Array.from(unique);
-            const result = Reflect.apply(target[prop], receiver, newArgs);
-            if (newArgs.length) {
-              mutateAddToRelatedRecords(this, {
-                value: extractIdentifiersFromRecords(newArgs),
-                index: 0
-              }, _SIGNAL);
-            }
-            return result;
-          }
-
-          // else, no dedupe, error on duplicates
-          const result = Reflect.apply(target[prop], receiver, args);
-          if (newValues.length) {
-            mutateAddToRelatedRecords(this, {
-              value: newValues,
-              index: 0
-            }, _SIGNAL);
-          }
-          return result;
-        }
-      case 'shift':
-        {
-          const result = Reflect.apply(target[prop], receiver, args);
-          if (result) {
-            mutateRemoveFromRelatedRecords(this, {
-              value: recordIdentifierFor(result),
-              index: 0
-            }, _SIGNAL);
-          }
-          return result;
-        }
-      case 'sort':
-        {
-          const result = Reflect.apply(target[prop], receiver, args);
-          mutateSortRelatedRecords(this, result.map(recordIdentifierFor), _SIGNAL);
-          return result;
-        }
-      case 'splice':
-        {
-          const [start, deleteCount, ...adds] = args;
-
-          // detect a full replace
-          if (start === 0 && deleteCount === this[SOURCE].length) {
-            const newValues = extractIdentifiersFromRecords(adds);
-            assertNoDuplicates(this, target, currentState => currentState.splice(start, deleteCount, ...newValues), `Cannot replace a hasMany's state with a new state that contains duplicates.`);
-            if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
-              // dedupe
-              const current = new Set(adds);
-              const unique = Array.from(current);
-              const newArgs = [start, deleteCount].concat(unique);
-              const result = Reflect.apply(target[prop], receiver, newArgs);
-              mutateReplaceRelatedRecords(this, extractIdentifiersFromRecords(unique), _SIGNAL);
-              return result;
-            }
-
-            // else, no dedupe, error on duplicates
-            const result = Reflect.apply(target[prop], receiver, args);
-            mutateReplaceRelatedRecords(this, newValues, _SIGNAL);
-            return result;
-          }
-          const newValues = extractIdentifiersFromRecords(adds);
-          assertNoDuplicates(this, target, currentState => currentState.splice(start, deleteCount, ...newValues), `Cannot splice a hasMany's state with a new state that contains duplicates.`);
-          if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES)) {
-            // dedupe
-            const currentState = target.slice();
-            currentState.splice(start, deleteCount);
-            const seen = new Set(currentState);
-            const unique = [];
-            adds.forEach(item => {
-              const identifier = recordIdentifierFor(item);
-              if (!seen.has(identifier)) {
-                seen.add(identifier);
-                unique.push(item);
-              }
-            });
-            const newArgs = [start, deleteCount, ...unique];
-            const result = Reflect.apply(target[prop], receiver, newArgs);
-            if (deleteCount > 0) {
-              mutateRemoveFromRelatedRecords(this, {
-                value: result.map(recordIdentifierFor),
-                index: start
-              }, _SIGNAL);
-            }
-            if (unique.length > 0) {
-              mutateAddToRelatedRecords(this, {
-                value: extractIdentifiersFromRecords(unique),
-                index: start
-              }, _SIGNAL);
-            }
-            return result;
-          }
-
-          // else, no dedupe, error on duplicates
-          const result = Reflect.apply(target[prop], receiver, args);
-          if (deleteCount > 0) {
-            mutateRemoveFromRelatedRecords(this, {
-              value: result.map(recordIdentifierFor),
-              index: start
-            }, _SIGNAL);
-          }
-          if (newValues.length > 0) {
-            mutateAddToRelatedRecords(this, {
-              value: newValues,
-              index: start
-            }, _SIGNAL);
-          }
-          return result;
-        }
-      default:
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          {
-            throw new Error(`unable to convert ${prop} into a transaction that updates the cache state for this record array`);
-          }
-        })() : {};
-    }
-  }
-  notify() {
-    notifyInternalSignal(this[ARRAY_SIGNAL]);
-  }
+  notify() {
+    notifyInternalSignal(this[ARRAY_SIGNAL]);
+  }
 
   /**
     Reloads all of the records in the manyArray. If the manyArray
@@ -6953,6 +7110,11 @@ function getPromise(promise) {
  *
  */
 function getPromiseState(promise) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`getPromiseState expects to be called with a promise: called with ${String(promise)}`);
+    }
+  })(promise) : {};
   const _promise = getPromise(promise);
   let state = PromiseCache.get(_promise);
   if (!state) {
@@ -6961,11 +7123,630 @@ function getPromiseState(promise) {
   }
   return state;
 }
+function decorateMethodV2(prototype, prop, decorators) {
+  const origDesc = Object.getOwnPropertyDescriptor(prototype, prop);
+  let desc = {
+    ...origDesc
+  };
+  for (let decorator of decorators) {
+    desc = decorator(prototype, prop, desc) || desc;
+  }
+  if (desc.initializer !== void 0) {
+    desc.value = desc.initializer ? desc.initializer.call(prototype) : void 0;
+    desc.initializer = void 0;
+  }
+  Object.defineProperty(prototype, prop, desc);
+}
+const DEFAULT_DEADLINE = 30_000;
+const DISPOSE = Symbol.dispose || Symbol.for('dispose');
+function isNeverString(val) {
+  return val;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+/**
+ * A reactive class
+ *
+ * @hideconstructor
+ */
+class RequestSubscription {
+  /**
+   * Whether the browser reports that the network is online.
+   */
+
+  /**
+   * Whether the browser reports that the tab is hidden.
+   */
+
+  /**
+   * Whether the component is currently refreshing the request.
+   */
+
+  /**
+   * The most recent blocking request that was made, typically
+   * the result of a reload.
+   *
+   * This will never be the original request passed as an arg to
+   * the component.
+   *
+   * @internal
+   */
+
+  /**
+   * The most recent request that was made, typically due to either a
+   * reload or a refresh.
+   *
+   * This will never be the original request passed as an arg to
+   * the component.
+   *
+   * @internal
+   */
+
+  /**
+   * The time at which the network was reported as offline.
+   *
+   * @internal
+   */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /**
+   * The event listener for network status changes,
+   * cached to use the reference for removal.
+   *
+   * @internal
+   */
+
+  /**
+   * The event listener for visibility status changes,
+   * cached to use the reference for removal.
+   *
+   * @internal
+   */
+
+  /**
+   * The last request passed as an arg to the component,
+   * cached for comparison.
+   *
+   * @internal
+   */
+
+  /**
+   * The last query passed as an arg to the component,
+   * cached for comparison.
+   *
+   * @internal
+   */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  constructor(store, args) {
+    this._args = args;
+    this.store = store;
+    this._subscribedTo = null;
+    this._subscription = null;
+    this._intervalStart = null;
+    this._invalidated = false;
+    this._nextInterval = null;
+    this.isDestroyed = false;
+    this[DISPOSE] = _DISPOSE;
+    this._installListeners();
+    void this._beginPolling();
+  }
+
+  /**
+   * @internal
+   */
+  async _beginPolling() {
+    // await the initial request
+    try {
+      if (!this.isIdle) {
+        await this.request;
+      }
+    } catch {
+      // ignore errors here, we just want to wait for the request to finish
+    } finally {
+      if (!this.isDestroyed) {
+        void this._scheduleInterval();
+      }
+    }
+  }
+  get isIdle() {
+    const {
+      request,
+      query
+    } = this._args;
+    return Boolean(!request && !query);
+  }
+  static {
+    decorateMethodV2(this.prototype, "isIdle", [memoized]);
+  }
+  get autorefreshTypes() {
+    const {
+      autorefresh
+    } = this._args;
+    let types;
+    if (autorefresh === true) {
+      types = ['online', 'invalid'];
+    } else if (typeof autorefresh === 'string') {
+      types = autorefresh.split(',');
+    } else {
+      types = [];
+    }
+    return new Set(types);
+  }
+
+  // we only run this function on component creation
+  // and when an update is triggered, so it does not
+  // react to changes in the autorefreshThreshold
+  // or autorefresh args.
+  //
+  // if we need to react to those changes, we can
+  // use a modifier or internal component or some
+  // such to trigger a re-run of this function.
+  static {
+    decorateMethodV2(this.prototype, "autorefreshTypes", [memoized]);
+  }
+  async _scheduleInterval() {
+    const {
+      autorefreshThreshold
+    } = this._args;
+    const hasValidThreshold = typeof autorefreshThreshold === 'number' && autorefreshThreshold > 0;
+    if (
+    // dont schedule in SSR
+    typeof window === 'undefined' ||
+    // dont schedule without a threshold
+    !hasValidThreshold ||
+    // dont schedule if we weren't told to
+    !this.autorefreshTypes.has('interval') ||
+    // dont schedule if we're already scheduled
+    this._intervalStart !== null) {
+      return;
+    }
+
+    // if we have a current request, wait for it to finish
+    // before scheduling the next one
+    if (this._latestRequest) {
+      try {
+        await this._latestRequest;
+      } catch {
+        // ignore errors here, we just want to wait for the request to finish
+      }
+      if (this.isDestroyed) {
+        return;
+      }
+    }
+
+    // setup the next interval
+    this._intervalStart = Date.now();
+    this._nextInterval = setTimeout(() => {
+      this._maybeUpdate();
+    }, autorefreshThreshold);
+  }
+  _clearInterval() {
+    if (this._nextInterval) {
+      clearTimeout(this._nextInterval);
+      this._intervalStart = null;
+    }
+  }
+  /**
+   * @internal
+   */
+  _updateSubscriptions() {
+    if (this.isIdle) {
+      return;
+    }
+    const requestId = this._request.lid;
+
+    // if we're already subscribed to this request, we don't need to do anything
+    if (this._subscribedTo === requestId) {
+      return;
+    }
+
+    // if we're subscribed to a different request, we need to unsubscribe
+    this._removeSubscriptions();
+
+    // if we have a request, we need to subscribe to it
+    const {
+      store
+    } = this;
+    if (requestId && isStore(store)) {
+      this._subscribedTo = requestId;
+      this._subscription = store.notifications.subscribe(requestId, (_id, op) => {
+        // ignore subscription events that occur while our own component's request
+        // is ocurring
+        if (this._isUpdating) {
+          return;
+        }
+        switch (op) {
+          case 'invalidated':
+            {
+              // if we're subscribed to invalidations, we need to update
+              if (this.autorefreshTypes.has('invalid')) {
+                this._invalidated = true;
+                this._maybeUpdate();
+              }
+              break;
+            }
+          case 'state':
+            {
+              const latest = store.requestManager._deduped.get(requestId);
+              const priority = latest?.priority;
+              const state = this.reqState;
+              if (!priority) {
+                // if there is no priority, we have completed whatever request
+                // was occurring and so we are no longer refreshing (if we were)
+                this.isRefreshing = false;
+              } else if (priority.blocking && !state.isLoading) {
+                // if we are blocking, there is an active request for this identity
+                // that MUST be fulfilled from network (not cache).
+                // Thus this is not "refreshing" because we should clear out and
+                // block on this request.
+                //
+                // we receive state notifications when either a request initiates
+                // or completes.
+                //
+                // In the completes case: we may receive the state notification
+                // slightly before the request is finalized because the NotificationManager
+                // may sync flush it (and thus deliver it before the microtask completes)
+                //
+                // In the initiates case: we aren't supposed to receive one unless there
+                // is no other request in flight for this identity.
+                //
+                // However, there is a race condition here where the completed
+                // notification can trigger an update that generates a new request
+                // thus giving us an initiated notification before the older request
+                // finalizes.
+                //
+                // When this occurs, if the triggered update happens to have caused
+                // a new request to be made for the same identity AND that request
+                // is the one passed into this component as the @request arg, then
+                // getRequestState will return the state of the new request.
+                // We can detect this by checking if the request state is "loading"
+                // as outside of this case we would have a completed request.
+                //
+                // That is the reason for the `&& !state.isLoading` check above.
+
+                // TODO should we just treat this as refreshing?
+                this.isRefreshing = false;
+                this._maybeUpdate('policy', true);
+              } else {
+                this.isRefreshing = true;
+              }
+            }
+        }
+      });
+    }
+  }
+
+  /**
+   * @internal
+   */
+  _removeSubscriptions() {
+    if (this._subscription && isStore(this.store)) {
+      this.store.notifications.unsubscribe(this._subscription);
+      this._subscribedTo = null;
+      this._subscription = null;
+    }
+  }
+
+  /**
+   * Install the event listeners for network and visibility changes.
+   * This is only done in browser environments with a global `window`.
+   *
+   * @internal
+   */
+  _installListeners() {
+    if (typeof window === 'undefined') {
+      return;
+    }
+    this.isOnline = window.navigator.onLine;
+    this._unavailableStart = this.isOnline ? null : Date.now();
+    this.isHidden = document.visibilityState === 'hidden';
+    this._onlineChanged = event => {
+      this.isOnline = event.type === 'online';
+      if (event.type === 'offline' && this._unavailableStart === null) {
+        this._unavailableStart = Date.now();
+      }
+      this._maybeUpdate();
+    };
+    this._backgroundChanged = () => {
+      const isHidden = document.visibilityState === 'hidden';
+      this.isHidden = isHidden;
+      if (isHidden && this._unavailableStart === null) {
+        this._unavailableStart = Date.now();
+      }
+      this._maybeUpdate();
+    };
+    window.addEventListener('online', this._onlineChanged, {
+      passive: true,
+      capture: true
+    });
+    window.addEventListener('offline', this._onlineChanged, {
+      passive: true,
+      capture: true
+    });
+    document.addEventListener('visibilitychange', this._backgroundChanged, {
+      passive: true,
+      capture: true
+    });
+  }
+
+  /**
+   * If the network is online and the tab is visible, either reload or refresh the request
+   * based on the component's configuration and the requested update mode.
+   *
+   * Valid modes are:
+   *
+   * - `'reload'`: Force a reload of the request.
+   * - `'refresh'`: Refresh the request in the background.
+   * - `'policy'`: Make the request, letting the store's configured CachePolicy decide whether to reload, refresh, or do nothing.
+   * - `undefined`: Make the request using the component's autorefreshBehavior setting if the autorefreshThreshold has passed.
+   *
+   * @internal
+   */
+  _maybeUpdate(mode, silent) {
+    if (this.isIdle) {
+      return;
+    }
+    const canAttempt = Boolean(this.isOnline && !this.isHidden && (mode || this.autorefreshTypes.size));
+    if (!canAttempt) {
+      if (!silent && mode && mode !== '_invalidated') {
+        throw new Error(`Reload not available: the network is not online or the tab is hidden`);
+      }
+      return;
+    }
+    const {
+      autorefreshTypes
+    } = this;
+    let shouldAttempt = this._invalidated || Boolean(mode);
+    if (!shouldAttempt && autorefreshTypes.has('online')) {
+      const {
+        _unavailableStart
+      } = this;
+      const {
+        autorefreshThreshold
+      } = this._args;
+      const deadline = typeof autorefreshThreshold === 'number' ? autorefreshThreshold : DEFAULT_DEADLINE;
+      shouldAttempt = Boolean(_unavailableStart && Date.now() - _unavailableStart > deadline);
+    }
+    if (!shouldAttempt && autorefreshTypes.has('interval')) {
+      const {
+        _intervalStart
+      } = this;
+      const {
+        autorefreshThreshold
+      } = this._args;
+      if (_intervalStart && typeof autorefreshThreshold === 'number' && autorefreshThreshold > 0) {
+        shouldAttempt = Boolean(Date.now() - _intervalStart >= autorefreshThreshold);
+      }
+    }
+    this._unavailableStart = null;
+    this._invalidated = false;
+    if (shouldAttempt) {
+      this._clearInterval();
+      const request = Object.assign({}, this.reqState.request);
+      const realMode = mode === '_invalidated' ? null : mode;
+      const val = realMode ?? this._args.autorefreshBehavior ?? 'policy';
+      switch (val) {
+        case 'reload':
+          request.cacheOptions = Object.assign({}, request.cacheOptions, {
+            reload: true
+          });
+          break;
+        case 'refresh':
+          request.cacheOptions = Object.assign({}, request.cacheOptions, {
+            backgroundReload: true
+          });
+          break;
+        case 'policy':
+          break;
+        default:
+          throw new Error(`Invalid ${mode ? 'update mode' : '@autorefreshBehavior'} for <Request />: ${isNeverString(val)}`);
+      }
+      const wasStoreRequest = request[EnableHydration] === true;
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Cannot supply a different store than was used to create the request`);
+        }
+      })(!request.store || request.store === this.store) : {};
+      const store = request.store || this.store;
+      const requester = wasStoreRequest && 'requestManager' in store ? store.requestManager : store;
+      this._isUpdating = true;
+      this._latestRequest = requester.request(request);
+      if (val !== 'refresh') {
+        this._localRequest = this._latestRequest;
+      }
+      void this._scheduleInterval();
+      void this._latestRequest.finally(() => {
+        this._isUpdating = false;
+      });
+    }
+  }
+
+  /**
+   * Retry the request, reloading it from the server.
+   */
+  retry = async () => {
+    this._maybeUpdate('reload');
+    await this._localRequest;
+  };
+
+  /**
+   * Refresh the request, updating it in the background.
+   */
+  refresh = async () => {
+    this._maybeUpdate('refresh');
+    await this._latestRequest;
+  };
+
+  /**
+   * features to yield to the error slot of a component
+   */
+  get errorFeatures() {
+    return {
+      isHidden: this.isHidden,
+      isOnline: this.isOnline,
+      retry: this.retry
+    };
+  }
+
+  /**
+   * features to yield to the content slot of a component
+   */
+  static {
+    decorateMethodV2(this.prototype, "errorFeatures", [memoized]);
+  }
+  get contentFeatures() {
+    const feat = {
+      isHidden: this.isHidden,
+      isOnline: this.isOnline,
+      reload: this.retry,
+      refresh: this.refresh,
+      isRefreshing: this.isRefreshing,
+      latestRequest: this._latestRequest
+    };
+    if (feat.isRefreshing) {
+      feat.abort = () => {
+        this._latestRequest?.abort();
+      };
+    }
+    return feat;
+  }
+
+  /**
+   * @internal
+   */
+  static {
+    decorateMethodV2(this.prototype, "contentFeatures", [memoized]);
+  }
+  get _request() {
+    const {
+      request,
+      query
+    } = this._args;
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Cannot use both @request and @query args with the <Request> component`);
+      }
+    })(!request || !query) : {};
+    const {
+      _localRequest,
+      _originalRequest,
+      _originalQuery
+    } = this;
+    const isOriginalRequest = request === _originalRequest && query === _originalQuery;
+    if (_localRequest && isOriginalRequest) {
+      return _localRequest;
+    }
+
+    // update state checks for the next time
+    this._originalQuery = query;
+    this._originalRequest = request;
+    if (request) {
+      return request;
+    }
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You must provide either @request or an @query arg with the <Request> component`);
+      }
+    })(query) : {};
+    // @ts-expect-error TODO investigate this
+    return this.store.request(query);
+  }
+  static {
+    decorateMethodV2(this.prototype, "_request", [memoized]);
+  }
+  get request() {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+      try {
+        const request = this._request;
+        this._updateSubscriptions();
+        return request;
+      } catch (e) {
+        // eslint-disable-next-line no-console
+        console.log(e);
+        throw new Error(`Unable to initialize the request`, {
+          cause: e
+        });
+      }
+    } else {
+      const request = this._request;
+      this._updateSubscriptions();
+      return request;
+    }
+  }
+  static {
+    decorateMethodV2(this.prototype, "request", [memoized]);
+  }
+  get reqState() {
+    return getRequestState(this.request);
+  }
+  get result() {
+    return this.reqState.result;
+  }
+}
+defineSignal(RequestSubscription.prototype, 'isOnline', true);
+defineSignal(RequestSubscription.prototype, 'isHidden', false);
+defineSignal(RequestSubscription.prototype, 'isRefreshing', false);
+defineSignal(RequestSubscription.prototype, '_localRequest', undefined);
+defineSignal(RequestSubscription.prototype, '_latestRequest', undefined);
+function isStore(store) {
+  return 'requestManager' in store;
+}
+function createRequestSubscription(store, args) {
+  return new RequestSubscription(store, args);
+}
+function upgradeSubscription(sub) {
+  return sub;
+}
+function _DISPOSE() {
+  const self = upgradeSubscription(this);
+  self.isDestroyed = true;
+  self._removeSubscriptions();
+  if (typeof window === 'undefined') {
+    return;
+  }
+  self._clearInterval();
+  window.removeEventListener('online', self._onlineChanged, {
+    passive: true,
+    capture: true
+  });
+  window.removeEventListener('offline', self._onlineChanged, {
+    passive: true,
+    capture: true
+  });
+  document.removeEventListener('visibilitychange', self._backgroundChanged, {
+    passive: true,
+    capture: true
+  });
+}
 const RequestCache = new WeakMap();
 function isAbortError(error) {
   return error instanceof DOMException && error.name === 'AbortError';
 }
-async function watchStream(stream, state) {
+function upgradeLoadingState(state) {
+  return state;
+}
+async function watchStream(stream, loadingState) {
+  const state = upgradeLoadingState(loadingState);
   const reader = stream.getReader();
   let bytesLoaded = 0;
   let shouldForward = state._stream !== null && state._stream.readable.locked;
@@ -7355,4 +8136,4 @@ function getRequestState(future) {
   }
   return state;
 }
-export { peekInternalSignal as A, withSignalStore as B, Collection as C, notifyInternalSignal as D, consumeInternalSignal as E, getOrCreateInternalSignal as F, ReactiveDocument as G, setIdentifierGenerationMethod as H, IdentifierArray as I, setIdentifierUpdateMethod as J, setIdentifierForgetMethod as K, setIdentifierResetMethod as L, MUTATE as M, setKeyInfoForResource as N, RecordArrayManager as R, Store as S, _clearCaches as _, isDocumentIdentifier as a, coerceId as b, constructResource as c, SOURCE as d, ensureStringId as e, fastPush as f, removeRecordDataFor as g, setRecordIdentifier as h, isStableIdentifier as i, StoreMap as j, setCacheFor as k, RelatedCollection as l, log as m, normalizeModelName as n, logGroup as o, peekCache as p, getPromiseState as q, recordIdentifierFor as r, storeFor as s, getRequestState as t, memoized as u, gate as v, entangleSignal as w, defineSignal as x, defineNonEnumerableSignal as y, Signals as z };
+export { Signals as A, peekInternalSignal as B, Collection as C, DISPOSE as D, withSignalStore as E, notifyInternalSignal as F, consumeInternalSignal as G, getOrCreateInternalSignal as H, IdentifierArray as I, ReactiveDocument as J, setIdentifierGenerationMethod as K, setIdentifierUpdateMethod as L, MUTATE as M, setIdentifierForgetMethod as N, setIdentifierResetMethod as O, setKeyInfoForResource as P, isExtensionProp as Q, RecordArrayManager as R, Store as S, performExtensionSet as T, performArrayExtensionGet as U, performObjectExtensionGet as V, _clearCaches as _, isDocumentIdentifier as a, coerceId as b, constructResource as c, SOURCE as d, ensureStringId as e, fastPush as f, removeRecordDataFor as g, setRecordIdentifier as h, isStableIdentifier as i, StoreMap as j, setCacheFor as k, RelatedCollection as l, log as m, normalizeModelName as n, logGroup as o, peekCache as p, getPromiseState as q, recordIdentifierFor as r, storeFor as s, createRequestSubscription as t, getRequestState as u, memoized as v, gate as w, entangleSignal as x, defineSignal as y, defineNonEnumerableSignal as z };