@warp-drive/core 5.8.0-alpha.37 → 5.8.0-alpha.40

package/dist/unpkg/dev-deprecated/{index-D4si_DxB.js → index-BBlq5is_.js}

@@ -1,16 +1,16 @@
-import { deprecate, warn } from '@ember/debug';
 import { EnableHydration, SkipCache, STRUCTURED } from './types/request.js';
-import { macroCondition, getGlobalConfig, dependencySatisfies, importSync } from '@embroider/macros';
-import { D as Destroy, C as Context, S as SOURCE, a as Checkout, b as Commit } from "./symbols-sql1_mdx.js";
+import { D as Destroy, a as Context, S as SOURCE, C as Checkout, b as Commit } from "./-private-3C1OkYtZ.js";
 import { isResourceSchema } from './types/schema/fields.js';
-import { w as withBrand, g as getPromiseResult, s as setPromiseResult, c as cloneResponseProperties, I as IS_CACHE_HANDLER, a as assertValidRequest, e as executeNextHandler, b as getRequestResult, u as upgradePromise, d as clearRequestResult } from "./request-oqoLC9rz.js";
+import { w as withBrand, g as getPromiseResult, s as setPromiseResult, c as cloneResponseProperties, I as IS_CACHE_HANDLER, a as assertValidRequest, e as executeNextHandler, b as getRequestResult, u as upgradePromise, d as clearRequestResult } from "./request-CA9K0gXq.js";
 import { getOrSetGlobal, peekTransient, setTransient, peekUniversalTransient, setUniversalTransient } from './types/-private.js';
-import { c as createSignal, a as consumeSignal, n as notifySignal, b as createMemo, d as willSyncFlushWatchers, A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, w as waitFor } from "./configure-C3x8YXzL.js";
+import { c as createSignal, a as consumeSignal, n as notifySignal, b as createMemo, d as willSyncFlushWatchers, A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, w as waitFor } from "./configure-BC66sfNO.js";
 import { CACHE_OWNER, DEBUG_STALE_CACHE_OWNER, DEBUG_KEY_TYPE, DEBUG_CLIENT_ORIGINATED } from './types/identifier.js';
 import { dasherize } from './utils/string.js';
-import { D as DefaultCachePolicy } from "./default-cache-policy-D7_u4YRH.js";
+import { g as getGlobalConfig } from "./runtime-DfhJzpZH.js";
+import { DefaultCachePolicy } from './store.js';
 import { setLogging, getRuntimeConfig } from './types/runtime.js';
 import { RecordStore, Type } from './types/symbols.js';
+import * as _importSync20 from '@ember/object';
 const INITIALIZER_PROTO = {
   isInitializer: true
 };
@@ -98,11 +98,11 @@ function withSignalStore(obj) {
  * @private
  */
 function initializeSignalStore(obj) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Signal store already exists on object`);
     }
-  })(!obj[Signals]) : {};
+  })(!obj[Signals]);
   obj[Signals] = new Map();
 }
 function createInternalSignal(signals, obj, key, initialValue) {
@@ -124,17 +124,13 @@ function getOrCreateInternalSignal(signals, obj, key, initialValue) {
   return signal;
 }
 function createInternalMemo(signals, object, key, fn) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Expected no signal/memo to exist for key "${String(key)}"`);
     }
-  })(!peekInternalSignal(signals, key)) : {};
-  if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+  })(!peekInternalSignal(signals, key));
+  {
     return withFrame(signals, object, key, fn);
-  } else {
-    const memo = createMemo(object, key, fn);
-    signals.set(key, memo);
-    return memo;
   }
 }
 function peekInternalSignal(signals, key) {
@@ -187,7 +183,7 @@ function isMemo(obj) {
   // @ts-expect-error
   return typeof obj === 'function' && obj.signals instanceof Set;
 }
-if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+{
   // @ts-expect-error adding to global API
   globalThis.debugWarpDriveSignals = (obj, key) => {
     const signals = obj[Signals];
@@ -308,6 +304,14 @@ function printMemo(memo, key, lines = [], depth = 0) {
   }
   return lines;
 }
+
+/**
+ * Creates a signal for the key/object pairing and subscribes to the signal.
+ *
+ * Use when you need to ensure a signal exists and is subscribed to.
+ *
+ * @private
+ */
 function entangleSignal(signals, obj, key, initialValue) {
   let internalSignal = peekInternalSignal(signals, key);
   if (!internalSignal) {
@@ -375,16 +379,16 @@ function defineNonEnumerableSignal(obj, key, v) {
  */
 function signal(target, key, descriptor) {
   // Error on `@signal()`, `@signal(...args)``
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error('You attempted to use @signal(), which is not necessary nor supported. Remove the parentheses and you will be good to go!');
     }
-  })(target !== undefined) : {};
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  })(target !== undefined);
+  (test => {
     if (!test) {
       throw new Error(`You attempted to use @signal on with ${arguments.length > 1 ? 'arguments' : 'an argument'} ( @signal(${Array.from(arguments).map(d => `'${d}'`).join(', ')}) ), which is not supported. Dependencies are automatically tracked, so you can just use ${'`@signal`'}`);
     }
-  })(typeof target === 'object' && typeof key === 'string' && typeof descriptor === 'object' && arguments.length === 3) : {};
+  })(typeof target === 'object' && typeof key === 'string' && typeof descriptor === 'object' && arguments.length === 3);
   return createSignalDescriptor(key, descriptor.initializer ? makeInitializer(descriptor.initializer) : null);
 }
 
@@ -393,21 +397,21 @@ function signal(target, key, descriptor) {
  */
 function memoized(target, key, descriptor) {
   // Error on `@memoized()`, `@memoized(...args)`, and `@memoized propName = value;`
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error('You attempted to use @memoized(), which is not necessary nor supported. Remove the parentheses and you will be good to go!');
     }
-  })(target !== undefined) : {};
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  })(target !== undefined);
+  (test => {
     if (!test) {
       throw new Error(`You attempted to use @memoized on with ${arguments.length > 1 ? 'arguments' : 'an argument'} ( @memoized(${Array.from(arguments).map(d => `'${d}'`).join(', ')}), which is not supported. Dependencies are automatically tracked, so you can just use ${'`@memoized`'}`);
     }
-  })(typeof target === 'object' && typeof key === 'string' && typeof descriptor === 'object' && arguments.length === 3) : {};
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  })(typeof target === 'object' && typeof key === 'string' && typeof descriptor === 'object' && arguments.length === 3);
+  (test => {
     if (!test) {
       throw new Error(`The @memoized decorator must be applied to getters. '${key}' is not a getter.`);
     }
-  })(typeof descriptor.get === 'function') : {};
+  })(typeof descriptor.get === 'function');
 
   // eslint-disable-next-line @typescript-eslint/unbound-method
   const getter = descriptor.get;
@@ -512,11 +516,11 @@ const ReactiveDocumentProto = {
     url: '',
     method: 'GET'
   })) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`No self or related link`);
       }
-    })(this.links?.related || this.links?.self) : {};
+    })(this.links?.related || this.links?.self);
     options.cacheOptions = options.cacheOptions || {};
     options.cacheOptions.key = this.identifier?.lid;
     return this._request(this.links.related ? 'related' : 'self', options);
@@ -551,11 +555,11 @@ const ReactiveDocumentProto = {
     return data;
   },
   [Destroy]() {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Cannot destroy a ReactiveDocument which has already been destroyed`);
       }
-    })(this._store) : {};
+    })(this._store);
     if (this._subscription) {
       this._store.notifications.unsubscribe(this._subscription);
       // @ts-expect-error
@@ -580,11 +584,11 @@ defineGate(ReactiveDocumentProto, 'errors', {
       return;
     }
     const doc = this._store.cache.peek(identifier);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`No cache data was found for the document '${identifier.lid}'`);
       }
-    })(doc) : {};
+    })(doc);
     return 'errors' in doc ? doc.errors : undefined;
   }
 });
@@ -595,11 +599,11 @@ defineGate(ReactiveDocumentProto, 'data', {
       _localCache
     } = this;
     const doc = identifier ? this._store.cache.peek(identifier) : _localCache.document;
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`No cache data was found for the document '${identifier?.lid ?? '<uncached document>'}'`);
       }
-    })(doc) : {};
+    })(doc);
     const data = 'data' in doc ? doc.data : undefined;
     if (Array.isArray(data)) {
       return identifier ? this._store.recordArrayManager.getCollection({
@@ -624,11 +628,11 @@ defineGate(ReactiveDocumentProto, 'links', {
       return this._localCache.document.links;
     }
     const data = this._store.cache.peek(identifier);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`No cache data was found for the document '${identifier.lid}'`);
       }
-    })(data) : {};
+    })(data);
     return data.links;
   }
 });
@@ -641,11 +645,11 @@ defineGate(ReactiveDocumentProto, 'meta', {
       return this._localCache.document.meta;
     }
     const data = this._store.cache.peek(identifier);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`No cache data was found for the document '${identifier.lid}'`);
       }
-    })(data) : {};
+    })(data);
     return data.meta;
   }
 });
@@ -775,31 +779,24 @@ function hasId(resource) {
 function hasType(resource) {
   return hasProp(resource, 'type');
 }
+
+// Used by the store to normalize IDs entering the store.  Despite the fact
+// that developers may provide IDs as numbers (e.g., `store.findRecord('person', 1)`),
+// it is important that internally we use strings, since IDs may be serialized
+// and lose type information.  For example, Ember's router may put a record's
+// ID into the URL, and if we later try to deserialize that URL and find the
+// corresponding record, we will not know if it is a string or a number.
 function coerceId(id) {
-  if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_NON_STRICT_ID)) {
+  {
     let normalized;
     if (id === null || id === undefined || id === '') {
       normalized = null;
     } else {
       normalized = String(id);
     }
-    deprecate(`The resource id '<${typeof id}> ${String(id)} ' is not normalized. Update your application code to use '${JSON.stringify(normalized)}' instead.`, normalized === id, {
-      id: 'ember-data:deprecate-non-strict-id',
-      until: '6.0',
-      for: 'ember-data',
-      since: {
-        available: '4.13',
-        enabled: '5.3'
-      }
-    });
+    !(normalized === id) && console.warn(`The resource id '<${typeof id}> ${String(id)} ' is not normalized. Update your application code to use '${JSON.stringify(normalized)}' instead.`);
     return normalized;
   }
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Resource IDs must be a non-empty string or null. Received '${String(id)}'.`);
-    }
-  })(id === null || typeof id === 'string' && id.length > 0) : {};
-  return id;
 }
 function ensureStringId(id) {
   let normalized = null;
@@ -808,91 +805,38 @@ function ensureStringId(id) {
   } else if (typeof id === 'number' && !isNaN(id)) {
     normalized = String(id);
   }
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Expected id to be a string or number, received ${String(id)}`);
     }
-  })(normalized !== null) : {};
+  })(normalized !== null);
   return normalized;
 }
 function normalizeModelName(type) {
-  if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_NON_STRICT_TYPES)) {
+  {
     const result = dasherize(type);
-    deprecate(`The resource type '${type}' is not normalized. Update your application code to use '${result}' instead of '${type}'.`, result === type, {
-      id: 'ember-data:deprecate-non-strict-types',
-      until: '6.0',
-      for: 'ember-data',
-      since: {
-        available: '4.13',
-        enabled: '5.3'
-      }
-    });
+    !(result === type) && console.warn(`The resource type '${type}' is not normalized. Update your application code to use '${result}' instead of '${type}'.`);
     return result;
   }
-  return type;
-}
-function installPolyfill() {
-  const isFastBoot = typeof FastBoot !== 'undefined';
-  const CRYPTO = isFastBoot ? FastBoot.require('crypto') : globalThis.crypto;
-  if (!CRYPTO.randomUUID) {
-    // we might be able to optimize this by requesting more bytes than we need at a time
-    const rng = function () {
-      // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto
-      const rnds8 = new Uint8Array(16);
-      if (!CRYPTO.getRandomValues && !isFastBoot) {
-        throw new Error(`Unable to generate bytes for UUID`);
-      }
-      return CRYPTO.getRandomValues ? CRYPTO.getRandomValues(rnds8) : CRYPTO.randomFillSync(rnds8);
-    };
-
-    /*
-     * Convert array of 16 byte values to UUID string format of the form:
-     * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
-     */
-    const byteToHex = [];
-    for (let i = 0; i < 256; ++i) {
-      byteToHex[i] = (i + 0x100).toString(16).substr(1);
-    }
-    const bytesToUuid = function (buf) {
-      const bth = byteToHex;
-      // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4
-      return [bth[buf[0]], bth[buf[1]], bth[buf[2]], bth[buf[3]], '-', bth[buf[4]], bth[buf[5]], '-', bth[buf[6]], bth[buf[7]], '-', bth[buf[8]], bth[buf[9]], '-', bth[buf[10]], bth[buf[11]], bth[buf[12]], bth[buf[13]], bth[buf[14]], bth[buf[15]]].join('');
-    };
-    CRYPTO.randomUUID = function uuidv4() {
-      const rnds = rng();
-
-      // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
-      rnds[6] = rnds[6] & 0x0f | 0x40;
-      rnds[8] = rnds[8] & 0x3f | 0x80;
-      return bytesToUuid(rnds);
-    };
-  }
 }
 function isResourceKey(identifier) {
-  if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+  {
     return !!identifier && typeof identifier === 'object' && 'type' in identifier && 'id' in identifier && identifier.type !== '@document' && identifier[CACHE_OWNER] !== undefined;
-  } else {
-    return identifier.type !== '@document' && identifier[CACHE_OWNER] !== undefined;
   }
 }
 function isRequestKey(identifier) {
-  if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+  {
     return !!identifier && typeof identifier === 'object' && 'type' in identifier && !('id' in identifier) && identifier.type === '@document' && identifier[CACHE_OWNER] !== undefined;
-  } else {
-    return identifier.type === '@document' && identifier[CACHE_OWNER] !== undefined;
   }
 }
 const isFastBoot = typeof FastBoot !== 'undefined';
 const _crypto = isFastBoot ? FastBoot.require('crypto') : globalThis.crypto;
-if (macroCondition(getGlobalConfig().WarpDrive.polyfillUUID)) {
-  installPolyfill();
-}
 function uuidv4() {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error('crypto.randomUUID needs to be avaliable. Some browsers incorrectly disallow it in insecure contexts. You maybe want to enable the polyfill: https://github.com/warp-drive-data/warp-drive#randomuuid-polyfill');
     }
-  })(typeof _crypto.randomUUID === 'function') : {};
+  })(typeof _crypto.randomUUID === 'function');
   return _crypto.randomUUID();
 }
 function freeze(obj) {
@@ -1088,11 +1032,11 @@ function updateTypeIdMapping(typeMap, identifier, id) {
 }
 function defaultUpdateMethod(identifier, data, bucket) {
   if (bucket === 'record') {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Expected identifier to be a ResourceKey`);
       }
-    })(isResourceKey(identifier)) : {};
+    })(isResourceKey(identifier));
     if (!identifier.id && hasId(data)) {
       updateTypeIdMapping(NEW_IDENTIFIERS, identifier, data.id);
     }
@@ -1102,11 +1046,11 @@ function defaultKeyInfoMethod(resource, known) {
   // TODO RFC something to make this configurable
   const id = hasId(resource) ? coerceId(resource.id) : null;
   const type = hasType(resource) ? normalizeModelName(resource.type) : known ? known.type : null;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Expected keyInfoForResource to provide a type for the resource`);
     }
-  })(type) : {};
+  })(type);
   return {
     type,
     id
@@ -1117,11 +1061,11 @@ function defaultGenerationMethod(data, bucket) {
     if (hasLid(data)) {
       return data.lid;
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Cannot generate an identifier for a resource without a type`);
       }
-    })(hasType(data)) : {};
+    })(hasType(data));
     if (hasId(data)) {
       const type = normalizeModelName(data.type);
       const lid = NEW_IDENTIFIERS.get(type)?.get(data.id);
@@ -1137,18 +1081,18 @@ function defaultGenerationMethod(data, bucket) {
     }
     return null;
   }
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     {
       throw new Error(`Unknown bucket ${bucket}`);
     }
-  })() : {};
+  })();
 }
 function defaultEmptyCallback(...args) {}
 function defaultMergeMethod(a, _b, _c) {
   return a;
 }
 let DEBUG_MAP;
-if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+{
   DEBUG_MAP = getOrSetGlobal('DEBUG_MAP', new WeakMap());
 }
 
@@ -1225,21 +1169,20 @@ class CacheKeyManager {
 
   /** @internal */
   _getRecordIdentifier(resource, shouldGenerate) {
-    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+    {
       if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
         // eslint-disable-next-line no-console
         console.groupCollapsed(`Identifiers: ${shouldGenerate ? 'Generating' : 'Peeking'} Identifier`, resource);
       }
-    }
-    // short circuit if we're already the stable version
+    } // short circuit if we're already the stable version
     if (isResourceKey(resource)) {
-      if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+      {
         // TODO should we instead just treat this case as a new generation skipping the short circuit?
         if (!this._cache.resources.has(resource.lid) || this._cache.resources.get(resource.lid) !== resource) {
           throw new Error(`The supplied identifier ${JSON.stringify(resource)} does not belong to this store instance`);
         }
       }
-      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+      {
         if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
           // eslint-disable-next-line no-console
           console.log(`Identifiers: cache HIT - Stable ${resource.lid}`);
@@ -1252,7 +1195,7 @@ class CacheKeyManager {
 
     // the resource is unknown, ask the application to identify this data for us
     const lid = this._generate(resource, 'record');
-    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+    {
       if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
         // eslint-disable-next-line no-console
         console.log(`Identifiers: ${lid ? 'no ' : ''}lid ${lid ? lid + ' ' : ''}determined for resource`, resource);
@@ -1260,7 +1203,7 @@ class CacheKeyManager {
     }
     let identifier = /*#__NOINLINE__*/getIdentifierFromLid(this._cache, lid, resource);
     if (identifier !== null) {
-      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+      {
         if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
           // eslint-disable-next-line no-console
           console.groupEnd();
@@ -1269,7 +1212,7 @@ class CacheKeyManager {
       return identifier;
     }
     if (shouldGenerate === 0) {
-      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+      {
         if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
           // eslint-disable-next-line no-console
           console.groupEnd();
@@ -1291,7 +1234,7 @@ class CacheKeyManager {
       identifier = /*#__NOINLINE__*/makeResourceKey(keyInfo, 'record', false);
     }
     addResourceToCache(this._cache, identifier);
-    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+    {
       if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
         // eslint-disable-next-line no-console
         console.groupEnd();
@@ -1361,7 +1304,7 @@ class CacheKeyManager {
         type: '@document',
         [CACHE_OWNER]: this._id
       };
-      if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+      {
         Object.freeze(identifier);
       }
       this._cache.documents.set(cacheKey, identifier);
@@ -1400,7 +1343,7 @@ class CacheKeyManager {
     }, 'record', true);
 
     // populate our unique table
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       if (this._cache.resources.has(identifier.lid)) {
         throw new Error(`The lid generated for the new record is not unique as it matches an existing identifier`);
       }
@@ -1408,7 +1351,7 @@ class CacheKeyManager {
 
     /*#__NOINLINE__*/
     addResourceToCache(this._cache, identifier);
-    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+    {
       if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
         // eslint-disable-next-line no-console
         console.log(`Identifiers: created identifier ${String(identifier)} for newly generated resource`, data);
@@ -1456,7 +1399,7 @@ class CacheKeyManager {
       if (hadLid) {
         data.lid = identifier.lid;
       }
-      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+      {
         if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
           // eslint-disable-next-line no-console
           console.log(`Identifiers: merged identifiers ${generatedIdentifier.lid} and ${existingIdentifier.lid} for resource into ${identifier.lid}`, data);
@@ -1470,23 +1413,23 @@ class CacheKeyManager {
 
     // add to our own secondary lookup table
     if (id !== newId && newId !== null) {
-      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+      {
         if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
           // eslint-disable-next-line no-console
           console.log(`Identifiers: updated id for identifier ${identifier.lid} from '${String(id)}' to '${String(newId)}' for resource`, data);
         }
       }
       const typeSet = this._cache.resourcesByType[identifier.type];
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      (test => {
         if (!test) {
           throw new Error(`Expected to find a typeSet for ${identifier.type}`);
         }
-      })(typeSet) : {};
+      })(typeSet);
       typeSet.id.set(newId, identifier);
       if (id !== null) {
         typeSet.id.delete(id);
       }
-    } else if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+    } else {
       if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
         // eslint-disable-next-line no-console
         console.log(`Identifiers: updated identifier ${identifier.lid} resource`, data);
@@ -1499,11 +1442,11 @@ class CacheKeyManager {
    * @internal
    */
   _mergeRecordIdentifiers(keyInfo, identifier, existingIdentifier, data) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Expected keyInfo to contain an id`);
       }
-    })(hasId(keyInfo)) : {};
+    })(hasId(keyInfo));
     // delegate determining which identifier to keep to the configured MergeMethod
     const kept = this._merge(identifier, existingIdentifier, data);
     const abandoned = kept === identifier ? existingIdentifier : identifier;
@@ -1549,11 +1492,11 @@ class CacheKeyManager {
   forgetRecordIdentifier(identifierObject) {
     const identifier = this.getOrCreateRecordIdentifier(identifierObject);
     const typeSet = this._cache.resourcesByType[identifier.type];
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Expected to find a typeSet for ${identifier.type}`);
       }
-    })(typeSet) : {};
+    })(typeSet);
     if (identifier.id !== null) {
       typeSet.id.delete(identifier.id);
     }
@@ -1566,12 +1509,12 @@ class CacheKeyManager {
       });
       this._cache.polymorphicLidBackMap.delete(identifier.lid);
     }
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       identifier[DEBUG_STALE_CACHE_OWNER] = identifier[CACHE_OWNER];
     }
     identifier[CACHE_OWNER] = undefined;
     this._forget(identifier, 'record');
-    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+    {
       if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
         // eslint-disable-next-line no-console
         console.log(`Identifiers: released identifier ${identifierObject.lid}`);
@@ -1595,7 +1538,7 @@ class CacheKeyManager {
  */
 
 function makeResourceKey(recordIdentifier, bucket, clientOriginated) {
-  if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+  {
     // we enforce immutability in dev
     //  but preserve our ability to do controlled updates to the reference
     let wrapper = {
@@ -1656,10 +1599,9 @@ function makeResourceKey(recordIdentifier, bucket, clientOriginated) {
     wrapper = freeze(wrapper);
     return wrapper;
   }
-  return recordIdentifier;
 }
 function performRecordIdentifierUpdate(identifier, keyInfo, data, updateFn) {
-  if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+  {
     const {
       id,
       type
@@ -1677,7 +1619,7 @@ function performRecordIdentifierUpdate(identifier, keyInfo, data, updateFn) {
     if (id && identifier.id !== null && identifier.id !== id) {
       // here we warn and ignore, as this may be a mistake, but we allow the user
       // to have multiple cache-keys pointing at a single lid so we cannot error
-      warn(`The 'id' for a ResourceKey should not be updated once it has been set. Attempted to set id for '${wrapper.lid}' to '${id}'.`, false, {
+      console.warn(`The 'id' for a ResourceKey should not be updated once it has been set. Attempted to set id for '${wrapper.lid}' to '${id}'.`, false, {
         id: 'ember-data:multiple-ids-for-identifier'
       });
     }
@@ -1687,8 +1629,6 @@ function performRecordIdentifierUpdate(identifier, keyInfo, data, updateFn) {
       throw new Error(`The 'type' for a ResourceKey cannot be updated once it has been set. Attempted to set type for '${wrapper.lid}' to '${type}'.`);
     }
     updateFn(wrapper, data, 'record');
-  } else {
-    updateFn(identifier, data, 'record');
   }
 
   // upgrade the ID, this is a "one time only" ability
@@ -1734,7 +1674,7 @@ function detectMerge(cache, keyInfo, identifier, data) {
 }
 function getIdentifierFromLid(cache, lid, resource) {
   const identifier = cache.resources.get(lid);
-  if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_IDENTIFIERS)) {
+  {
     if (getGlobalConfig().WarpDrive.debug.LOG_IDENTIFIERS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_IDENTIFIERS) {
       // eslint-disable-next-line no-console
       console.log(`Identifiers: cache ${identifier ? 'HIT' : 'MISS'} - Non-Stable ${lid}`, resource);
@@ -1816,11 +1756,11 @@ class CacheCapabilitiesManager {
     });
   }
   notifyChange(identifier, namespace, key) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Expected a stable identifier`);
       }
-    })(isResourceKey(identifier) || isRequestKey(identifier)) : {};
+    })(isResourceKey(identifier) || isRequestKey(identifier));
 
     // TODO do we still get value from this?
     if (namespace === 'relationships' && key) {
@@ -1835,22 +1775,22 @@ class CacheCapabilitiesManager {
     return this._store.schema;
   }
   setRecordId(identifier, id) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Expected a stable identifier`);
       }
-    })(isResourceKey(identifier)) : {};
+    })(isResourceKey(identifier));
     this._store._instanceCache.setRecordId(identifier, id);
   }
   hasRecord(identifier) {
     return Boolean(this._store._instanceCache.peek(identifier));
   }
   disconnectRecord(identifier) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Expected a stable identifier`);
       }
-    })(isResourceKey(identifier)) : {};
+    })(isResourceKey(identifier));
     this._store._instanceCache.disconnect(identifier);
     this._pendingNotifies.delete(identifier);
   }
@@ -1864,7 +1804,7 @@ class CacheCapabilitiesManager {
  * @private
  */
 
-if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA_SERVICE)) {
+{
   CacheCapabilitiesManager.prototype.getSchemaDefinitionService = function () {
     // FIXME add deprecation for this
     return this.schema;
@@ -1898,15 +1838,15 @@ function peekResourceKey(record) {
  */
 
 function recordIdentifierFor(record) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`${String(record)} is not a ReactiveResource or Model known to WarpDrive`);
     }
-  })(RecordCache.has(record)) : {};
+  })(RecordCache.has(record));
   return RecordCache.get(record);
 }
 function setRecordIdentifier(record, identifier) {
-  if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+  {
     if (RecordCache.has(record) && RecordCache.get(record) !== identifier) {
       throw new Error(`${String(record)} was already assigned an identifier`);
     }
@@ -1923,7 +1863,7 @@ function setRecordIdentifier(record, identifier) {
   RecordCache.set(record, identifier);
 }
 function removeRecordIdentifier(record) {
-  if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+  {
     if (!RecordCache.has(record)) {
       throw new Error(`${String(record)} had no assigned identifier to remove`);
     }
@@ -1938,11 +1878,11 @@ const StoreMap = getOrSetGlobal('StoreMap', new Map());
  */
 function storeFor(record, ignoreMissing) {
   const store = StoreMap.get(record);
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`A record in a disconnected state cannot utilize the store. This typically means the record has been destroyed, most commonly by unloading it.`);
     }
-  })(ignoreMissing || store) : {};
+  })(ignoreMissing || store);
   return store ?? null;
 }
 class InstanceCache {
@@ -1980,11 +1920,11 @@ class InstanceCache {
         if ('id' in resourceData) {
           throw new Error(`Failed to update the 'id' for the ResourceKey '${identifier.type}:${String(identifier.id)} (${identifier.lid})' to '${String(resourceData.id)}', because that id is already in use by '${matchedIdentifier.type}:${String(matchedIdentifier.id)} (${matchedIdentifier.lid})'`);
         }
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        (test => {
           {
             throw new Error(`Failed to update the ResourceKey '${identifier.type}:${String(identifier.id)} (${identifier.lid})' to merge with the detected duplicate identifier '${matchedIdentifier.type}:${String(matchedIdentifier.id)} (${String(matchedIdentifier.lid)})'`);
           }
-        })() : {};
+        })();
       }
       this.store.cache.patch({
         op: 'mergeIdentifiers',
@@ -2044,42 +1984,40 @@ class InstanceCache {
   }
   disconnect(identifier) {
     const record = this.__instances.record.get(identifier);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error('Cannot destroy record while it is still materialized');
       }
-    })(!isDestroyable(record) || record.isDestroyed || record.isDestroying) : {};
+    })(!isDestroyable(record) || record.isDestroyed || record.isDestroying);
     this.store._graph?.remove(identifier);
     this.store.cacheKeyManager.forgetRecordIdentifier(identifier);
     StoreMap.delete(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) {
         log('reactive-ui', '', identifier.type, identifier.lid, 'disconnected', '');
       }
     }
   }
   unloadRecord(identifier) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       const requests = this.store.getRequestStateService().getPendingRequestsForRecord(identifier);
       if (requests.some(req => {
         return req.type === 'mutation';
       })) {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        (test => {
           {
             throw new Error(`You can only unload a record which is not inFlight. '${String(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.groupCollapsed(`InstanceCache: unloading record for ${String(identifier)}`);
       }
-    }
-
-    // TODO is this join still necessary?
+    } // TODO is this join still necessary?
     this.store._join(() => {
       unloadRecord(this, identifier);
     });
@@ -2115,27 +2053,27 @@ class InstanceCache {
     const oldId = identifier.id;
 
     // ID absolutely can't be missing if the oldID is empty (missing Id in response for a new record)
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`'${type}' was saved to the server, but the response does not have an id and your record does not either.`);
       }
-    })(!(id === null && oldId === null)) : {};
+    })(!(id === null && oldId === null));
 
     // ID absolutely can't be different than oldID if oldID is not null
     // TODO this assertion and restriction may not strictly be needed in the identifiers world
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Cannot update the id for '${type}:${lid}' from '${String(oldId)}' to '${id}'.`);
       }
-    })(!(oldId !== null && id !== oldId)) : {};
+    })(!(oldId !== null && id !== oldId));
 
     // ID can be null if oldID is not null (altered ID in response for a record)
     // however, this is more than likely a developer error.
     if (oldId !== null && id === null) {
-      warn(`Your ${type} record was saved to the server, but the response does not have an id.`, !(oldId !== null && id === null));
+      console.warn(`Your ${type} record was saved to the server, but the response does not have an id.`, !(oldId !== null && id === null));
       return;
     }
-    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: updating id to '${id}' for record ${String(identifier)}`);
@@ -2145,11 +2083,11 @@ class InstanceCache {
       type,
       id
     });
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`'${type}' was saved to the server, but the response returned the new id '${id}', which has already been used with another record.'`);
       }
-    })(!existingIdentifier || existingIdentifier === identifier) : {};
+    })(!existingIdentifier || existingIdentifier === identifier);
     if (identifier.id === null) {
       // TODO potentially this needs to handle merged result
       this.store.cacheKeyManager.updateRecordIdentifier(identifier, {
@@ -2182,16 +2120,16 @@ function getNewRecord(instances, identifier, properties) {
   return record;
 }
 function _createRecord(instances, identifier, properties) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Cannot create a new record instance while the store is being destroyed`);
     }
-  })(!instances.store.isDestroying && !instances.store.isDestroyed) : {};
+  })(!instances.store.isDestroying && !instances.store.isDestroyed);
   const record = instances.store.instantiateRecord(identifier, properties);
   setRecordIdentifier(record, identifier);
   StoreMap.set(record, instances.store);
   instances.__instances.record.set(identifier, record);
-  if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_INSTANCE_CACHE)) {
+  {
     if (getGlobalConfig().WarpDrive.debug.LOG_INSTANCE_CACHE || globalThis.getWarpDriveRuntimeConfig().debug.LOG_INSTANCE_CACHE) {
       logGroup('reactive-ui', '', identifier.type, identifier.lid, 'created', '');
       // eslint-disable-next-line no-console
@@ -2212,7 +2150,7 @@ function unloadRecord(instances, identifier) {
     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)}`);
@@ -2222,7 +2160,7 @@ function unloadRecord(instances, 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)}`);
@@ -2232,7 +2170,7 @@ function unloadRecord(instances, identifier) {
     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)}`);
@@ -2746,16 +2684,16 @@ function count(label) {
   globalThis.__WarpDriveMetricCountData[label] = (globalThis.__WarpDriveMetricCountData[label] || 0) + 1;
 }
 function asInternalToken(token) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Expected a token with a 'for' property`);
     }
-  })(token && typeof token === 'function' && 'for' in token) : {};
+  })(token && typeof token === 'function' && 'for' in token);
 }
 function _unsubscribe(token, cache) {
   asInternalToken(token);
   const cacheKey = token.for;
-  if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_NOTIFICATIONS)) {
+  {
     if (getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_NOTIFICATIONS) {
       if (!cacheKey) {
         // eslint-disable-next-line no-console
@@ -2770,11 +2708,11 @@ function _unsubscribe(token, cache) {
     }
     const index = callbacks.indexOf(token);
     if (index === -1) {
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      (test => {
         if (!test) {
           throw new Error(`Cannot unsubscribe a token that is not subscribed`);
         }
-      })(index !== -1) : {};
+      })(index !== -1);
       return;
     }
     callbacks.splice(index, 1);
@@ -2839,27 +2777,27 @@ class NotificationManager {
    */
 
   subscribe(cacheKey, callback) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Expected not to be destroyed`);
       }
-    })(!this.isDestroyed) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(!this.isDestroyed);
+    (test => {
       if (!test) {
         throw new Error(`Expected to receive a stable Identifier to subscribe to`);
       }
-    })(cacheKey === 'resource' || cacheKey === 'document' || isResourceKey(cacheKey) || isRequestKey(cacheKey)) : {};
+    })(cacheKey === 'resource' || cacheKey === 'document' || isResourceKey(cacheKey) || isRequestKey(cacheKey));
     let callbacks = this._cache.get(cacheKey);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`expected to receive a valid callback`);
       }
-    })(typeof callback === 'function') : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(typeof callback === 'function');
+    (test => {
       if (!test) {
         throw new Error(`cannot subscribe with the same callback twice`);
       }
-    })(!callbacks || !callbacks.includes(callback)) : {};
+    })(!callbacks || !callbacks.includes(callback));
     // we use the callback as the cancellation token
     //@ts-expect-error
     callback.for = cacheKey;
@@ -2892,13 +2830,13 @@ class NotificationManager {
     if (this.isDestroyed) {
       return false;
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Notify does not accept a key argument for the namespace '${value}'. Received key '${key || ''}'.`);
       }
-    })(!key || value === 'attributes' || value === 'relationships') : {};
+    })(!key || value === 'attributes' || value === 'relationships');
     if (!isResourceKey(cacheKey) && !isRequestKey(cacheKey)) {
-      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_NOTIFICATIONS)) {
+      {
         if (getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_NOTIFICATIONS) {
           // eslint-disable-next-line no-console
           console.log(`Notifying: Expected to receive a stable Identifier to notify '${value}' '${key || ''}' with, but ${String(cacheKey)} is not in the cache`, cacheKey);
@@ -2914,25 +2852,25 @@ class NotificationManager {
         this._buffered.set(cacheKey, buffer);
       }
       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 cacheKey ? cacheKey.type : '<document>'} ${value} ${key}`);
         }
       }
       if (!this._scheduleNotify()) {
-        if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_NOTIFICATIONS)) {
+        {
           if (getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_NOTIFICATIONS) {
             log('notify', 'buffered', `${'type' in cacheKey ? cacheKey.type : 'document'}`, cacheKey.lid, `${value}`, key || '');
           }
         }
       }
     } else {
-      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_NOTIFICATIONS)) {
+      {
         if (getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_NOTIFICATIONS) {
           log('notify', 'discarded', `${'type' in cacheKey ? cacheKey.type : 'document'}`, cacheKey.lid, `${value}`, key || '');
         }
       }
-      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_METRIC_COUNTS)) {
+      {
         if (getGlobalConfig().WarpDrive.debug.LOG_METRIC_COUNTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_METRIC_COUNTS) {
           count(`DISCARDED notify ${'type' in cacheKey ? cacheKey.type : '<document>'} ${value} ${key}`);
         }
@@ -2995,13 +2933,11 @@ class NotificationManager {
  */
 
 function _flushNotification(cache, cacheKey, value, key) {
-  if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_NOTIFICATIONS)) {
+  {
     if (getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_NOTIFICATIONS) {
       log('notify', '', `${'type' in cacheKey ? cacheKey.type : 'document'}`, cacheKey.lid, `${value}`, key || '');
     }
-  }
-
-  // TODO for documents this will need to switch based on Identifier kind
+  } // TODO for documents this will need to switch based on Identifier kind
   if (isCacheOperationValue(value)) {
     const callbackMap = cache.get(isRequestKey(cacheKey) ? 'document' : 'resource');
     if (callbackMap) {
@@ -3072,11 +3008,11 @@ function safeForEach$1(instance, arr, store, callback, target) {
   }
   // clone to prevent mutation
   arr = arr.slice();
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error('`forEach` expects a function as first argument.');
     }
-  })(typeof callback === 'function') : {};
+  })(typeof callback === 'function');
 
   // because we retrieveLatest above we need not worry if array is mutated during iteration
   // by unloadRecord/rollbackAttributes
@@ -3116,20 +3052,20 @@ function performObjectExtensionGet(receiver, extensions, signals, prop) {
       }
     case 'writeonly-field':
       {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        (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 => {
+        (test => {
           {
             throw new Error(`Unhandled extension kind ${desc.kind}`);
           }
-        })() : {};
+        })();
         return undefined;
       }
   }
@@ -3140,11 +3076,11 @@ function performExtensionSet(receiver, extensions, signals, prop, value) {
     case 'method':
     case 'readonly-value':
     case 'readonly-field':
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      (test => {
         {
           throw new Error(`Cannot set extension field ${String(prop)} as it is a ${desc.kind}`);
         }
-      })() : {};
+      })();
       return false;
     case 'mutable-value':
       {
@@ -3163,11 +3099,11 @@ function performExtensionSet(receiver, extensions, signals, prop, value) {
       }
     default:
       {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        (test => {
           {
             throw new Error(`Unhandled extension kind ${desc.kind}`);
           }
-        })() : {};
+        })();
         return false;
       }
   }
@@ -3207,20 +3143,20 @@ function performArrayExtensionGet(receiver, extensions, signals, prop, _SIGNAL,
       }
     case 'writeonly-field':
       {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        (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 => {
+        (test => {
           {
             throw new Error(`Unhandled extension kind ${desc.kind}`);
           }
-        })() : {};
+        })();
         return undefined;
       }
   }
@@ -3255,7 +3191,7 @@ const ARR_BRACKET_DESC = {
   get: function () {
     // here to support computed chains
     // and {{#each}}
-    if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_COMPUTED_CHAINS)) {
+    {
       return this;
     }
   }
@@ -3343,19 +3279,19 @@ const ArrayHandler = {
           // 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 => {
+            (test => {
               if (!test) {
                 throw new Error(`Mutating this array of records via ${String(prop)} is not allowed.`);
               }
-            })(CONTEXT.editable) : {};
+            })(CONTEXT.editable);
             return;
           }
           const args = Array.prototype.slice.call(arguments);
-          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          (test => {
             if (!test) {
               throw new Error(`Cannot start a new array transaction while a previous transaction is underway`);
             }
-          })(!CONTEXT.transaction) : {};
+          })(!CONTEXT.transaction);
           CONTEXT.transaction = true;
           const result = CONTEXT.mutate(target, receiver, prop, args, CONTEXT.signal);
           CONTEXT.transaction = false;
@@ -3395,11 +3331,11 @@ const ArrayHandler = {
       return true;
     }
     if (!CONTEXT.editable && !MUTABLE_PROPS.includes(prop)) {
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      (test => {
         if (!test) {
           throw new Error(`Mutating ${String(prop)} on this Array is not allowed.`);
         }
-      })(CONTEXT.editable) : {};
+      })(CONTEXT.editable);
       return false;
     }
     if (prop === 'length') {
@@ -3411,11 +3347,11 @@ const ArrayHandler = {
       } else if (CONTEXT.transaction) {
         return Reflect.set(target, prop, value);
       } else {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        (test => {
           {
             throw new Error(`unexpected length set`);
           }
-        })() : {};
+        })();
       }
     }
     if (isContextProp(prop)) {
@@ -3448,11 +3384,11 @@ const ArrayHandler = {
     if (index === null || index > target.length) {
       if (index !== null && CONTEXT.transaction) {
         const identifier = recordIdentifierFor(value);
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        (test => {
           if (!test) {
             throw new Error(`Cannot set index ${index} past the end of the array.`);
           }
-        })(isResourceKey(identifier)) : {};
+        })(isResourceKey(identifier));
         target[index] = identifier;
         return true;
       } else if (CONTEXT.features && prop in CONTEXT.features) {
@@ -3463,11 +3399,11 @@ const ArrayHandler = {
     }
     const original = target[index];
     const newIdentifier = extractIdentifierFromRecord$2(value);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Expected a record`);
       }
-    })(newIdentifier && isResourceKey(newIdentifier)) : {};
+    })(newIdentifier && isResourceKey(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.
@@ -3493,11 +3429,11 @@ const ArrayHandler = {
   },
   deleteProperty(target, prop) {
     const CONTEXT = target[Context];
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Deleting keys on managed arrays is disallowed`);
       }
-    })(CONTEXT.transaction) : {};
+    })(CONTEXT.transaction);
     if (!CONTEXT.transaction) {
       return false;
     }
@@ -3508,11 +3444,11 @@ const ArrayHandler = {
   }
 };
 const ILLEGAL_MUTATION = () => {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     {
       throw new Error(`ILLEGAL OPERATION: This ReactiveResourceArray is immutable`);
     }
-  })() : {};
+  })();
 };
 function createReactiveResourceArray(options) {
   const TARGET = options.source;
@@ -3536,7 +3472,7 @@ function createReactiveResourceArray(options) {
   };
   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,
@@ -3563,7 +3499,7 @@ function extractIdentifierFromRecord$2(record) {
   if (!record) {
     return null;
   }
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`All elements of a ReactiveResourceArray must be instances of a ReactiveResource, you passed $${typeof record}`);
     }
@@ -3574,7 +3510,7 @@ function extractIdentifierFromRecord$2(record) {
     } catch {
       return false;
     }
-  }()) : {};
+  }());
   return recordIdentifierFor(record);
 }
 function destroy(clear) {
@@ -3601,6 +3537,69 @@ function createRequestCollection(config) {
   });
 }
 
+/**
+ * LiveArrays contain all the known records for a given `ResourceType`.
+ *
+ * ### Basic Example
+ *
+ * For instance, if an application were to have a `'user'` type:
+ *
+ * ```ts
+ * const usersLiveArray = store.peekAll('user');
+ * ```
+ *
+ * ---
+ *
+ * &nbsp;
+ *
+ * ### LiveArrays are Arrays
+ *
+ * LiveArrays have all array APIs, and will report `true`
+ * for both `liveArray instanceof Array` and `Array.isArray(liveArray)`
+ *
+ * ---
+ *
+ * &nbsp;
+ *
+ * ### Reactive
+ *
+ * The array is "live" as it will reactively update any time new
+ * users are added to the store's cache.
+ *
+ * There is only one LiveArray instance per ResourceType, and it
+ * can be accessed either via {@link Store.peekAll} or {@link Store.findAll}
+ *
+ * ```ts
+ * const users = await store.findAll('user');
+ * const peekedUsers = store.peekAll('user');
+ * peekedUsers === users; // true
+ * ```
+ *
+ * ---
+ *
+ * &nbsp;
+ *
+ * ### New Records
+ *
+ * Records in the `"new"` state (created locally on the client
+ * but not yet saved) appear in LiveArrays if they are in LegacyMode.
+ *
+ * PolarisMode records in the `"new"` state do not appear in LiveArrays.
+ *
+ * ---
+ *
+ * &nbsp;
+ *
+ * ### Polymorphism
+ *
+ * LiveArrays are not polymorphic. If your application has an abstract
+ * type "car" with concrete types "ferrari" and "bmw", then "ferrari"
+ * and "bmw" will have populated LiveArrays, but the LiveArray for "car"
+ * would be empty.
+ *
+ * @legacy we recommend againt using LiveArrays. Use {@link Store.request} instead
+ */
+
 /**
  * The options for {@link createLegacyLiveArray}
  *
@@ -3636,11 +3635,11 @@ function createLegacyLiveArray(options) {
 }
 function _updateLiveArray() {
   const context = this[Context];
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`_update cannot be used with this array`);
     }
-  })(this.modelName) : {};
+  })(this.modelName);
   // @ts-expect-error typescript is unable to handle the complexity of
   //   T = unknown, modelName = string
   //   T extends TypedRecordInstance, modelName = TypeFromInstance<T>
@@ -3650,6 +3649,79 @@ function _updateLiveArray() {
   });
 }
 
+/**
+ * QueryArrays contain the primary records returned when querying
+ * for records by `ResourceType`.
+ *
+ * ### Basic Example
+ *
+ * For instance, if an application were to have a `'user'` type:
+ *
+ * ```ts
+ * const users = await store.query('user', { name: 'Chris' });
+ * ```
+ *
+ * ---
+ *
+ * &nbsp;
+ *
+ * ### QueryArrays are Arrays
+ *
+ * QueryArrays have all array APIs, and will report `true`
+ * for both `queryArray instanceof Array` and `Array.isArray(queryArray)`
+ *
+ * However, any mutation of the array will throw an error.
+ *
+ * ---
+ *
+ * &nbsp;
+ *
+ * ### Reactive
+ *
+ * If a record in a QueryArray is deleted and unloaded, it will be
+ * automatically removed from the array.
+ *
+ * ---
+ *
+ * &nbsp;
+ *
+ * ### Immutable
+ *
+ * Records cannot be directly added to or removed from a QueryArray.
+ *
+ * ---
+ *
+ * &nbsp;
+ *
+ * ### Polymorphism
+ *
+ * QueryArrays are not intended to be polymorphic. If your application has
+ * an abstract type "car" with concrete types "ferrari" and "bmw", a query
+ * which returns primary data containing both ferraris and bmws will *likely*
+ * work, but it is not guaranteed.
+ *
+ * In contrast, the {@link ReactiveResourceArray} returned when using {@link Store.request}
+ * is guaranteed to work with polymorphic responses.
+ *
+ * ---
+ *
+ * &nbsp;
+ *
+ * ### Memory Leaks
+ *
+ * QueryArrays are meant to be long lived. They can be refreshed using
+ * `array.update()`, and destroyed via `array.destroy()`.
+ *
+ * Unlike most Reactive state in WarpDrive, applications must choose to call
+ * `destroy` when the `QueryArray` is no longer needed, else the array instance
+ * will be retained until either the application or the store which created it
+ * are destroyed. Destroying a QueryArray does not remove its records
+ * from the cache, but it does remove the array as well as the overhead it requires
+ * from the store for book-keeping.
+ *
+ * @legacy we recommend againt using QueryArrays. Use {@link Store.request} instead
+ */
+
 /**
  * The options for {@link createLegacyQueryArray}
  *
@@ -3697,16 +3769,16 @@ function _updateCollection() {
   const {
     query
   } = this;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`update cannot be used with this array`);
     }
-  })(this.modelName) : {};
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  })(this.modelName);
+  (test => {
     if (!test) {
       throw new Error(`update cannot be used with no query`);
     }
-  })(query) : {};
+  })(query);
   // @ts-expect-error typescript is unable to handle the complexity of
   //   T = unknown, modelName = string
   //   T extends TypedRecordInstance, modelName = TypeFromInstance<T>
@@ -3909,11 +3981,11 @@ class RecordArrayManager {
       // due to notification that the cache has changed
       if (signal.value === 'cache-sync') {
         const doc = this.store.cache.peek(identifier);
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        (test => {
           if (!test) {
             throw new Error(`Expected to find a document for ${identifier.lid} but found none`);
           }
-        })(doc) : {};
+        })(doc);
         const data = !('data' in doc) || !Array.isArray(doc.data) ? [] : doc.data;
         // TODO technically we should destroy here if
         // !('data' in doc) || !Array.isArray(doc.data)
@@ -4072,11 +4144,11 @@ class RecordArrayManager {
   populateManagedArray(array, identifiers, payload) {
     this._pending.delete(array);
     const source = array[Context].source;
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`The new state of the collection should not be using the same array reference as the original state.`);
       }
-    })(source !== identifiers) : {};
+    })(source !== identifiers);
     const old = source.slice();
     source.length = 0;
     fastPush(source, identifiers);
@@ -4260,7 +4332,7 @@ function isLegacyLiveArray(array) {
 }
 const Touching = getOrSetGlobal('Touching', Symbol('touching'));
 const RequestPromise = getOrSetGlobal('RequestPromise', Symbol('promise'));
-const EMPTY_ARR = macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? Object.freeze([]) : [];
+const EMPTY_ARR = Object.freeze([]);
 function hasRecordIdentifier(op) {
   return 'recordIdentifier' in op;
 }
@@ -4338,11 +4410,11 @@ class RequestStateService {
         throw error;
       });
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       {
         throw new Error(`Expected a well formed  query`);
       }
-    })() : {};
+    })();
   }
 
   /** @internal */
@@ -4479,13 +4551,23 @@ class RequestStateService {
  * @private
  */
 
+function esCompat(m) {
+  return m?.__esModule ? m : {
+    default: m,
+    ...m
+  };
+}
+
 // this import location is deprecated but breaks in 4.8 and older
-// @ts-expect-error adding to globalThis
-globalThis.setWarpDriveLogging = setLogging;
 
-// @ts-expect-error adding to globalThis
-globalThis.getWarpDriveRuntimeConfig = getRuntimeConfig;
-if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_METRIC_COUNTS)) {
+{
+  // @ts-expect-error adding to globalThis
+  globalThis.setWarpDriveLogging = setLogging;
+
+  // @ts-expect-error adding to globalThis
+  globalThis.getWarpDriveRuntimeConfig = getRuntimeConfig;
+}
+{
   if (getGlobalConfig().WarpDrive.debug.LOG_METRIC_COUNTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_METRIC_COUNTS) {
     // @ts-expect-error adding to globalThis
     // eslint-disable-next-line
@@ -4503,7 +4585,7 @@ if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_METRIC_COUNTS))
       // @ts-expect-error
       globalThis.__WarpDriveMetricCountData = {};
     };
-    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS)) {
+    {
       if (getGlobalConfig().WarpDrive.debug.__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS || globalThis.getWarpDriveRuntimeConfig().debug.__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS) {
         // @ts-expect-error adding to globalThis
         globalThis.__primitiveInstanceId = 0;
@@ -4618,10 +4700,10 @@ const EmptyClass = class {
   // eslint-disable-next-line @typescript-eslint/no-useless-constructor
   constructor(args) {}
 };
-const _BaseClass = macroCondition(dependencySatisfies('ember-source', '*')) ? macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_STORE_EXTENDS_EMBER_OBJECT) ? importSync('@ember/object') : EmptyClass : EmptyClass;
+const _BaseClass = esCompat(_importSync20);
 const BaseClass = _BaseClass.default ? _BaseClass.default : _BaseClass;
 if (BaseClass !== EmptyClass) {
-  deprecate(`The Store class extending from EmberObject is deprecated.
+  console.warn(`The Store class extending from EmberObject is deprecated.
 Please remove usage of EmberObject APIs and mark your class as not requiring it.
 
 To mark the class as no longer extending from EmberObject, in ember-cli-build.js
@@ -4636,16 +4718,7 @@ const app = new EmberApp(defaults, {
   }
 });
 \`\`\`
-`, false, {
-    id: 'ember-data:deprecate-store-extends-ember-object',
-    until: '6.0',
-    for: 'ember-data',
-    url: 'https://deprecations.emberjs.com/id/ember-data-deprecate-store-extends-ember-object',
-    since: {
-      available: '4.13',
-      enabled: '5.4'
-    }
-  });
+`);
 }
 /**
  * ```ts
@@ -4833,13 +4906,13 @@ class Store extends BaseClass {
 
   /** @internal */
   _run(cb) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`WarpDrive should never encounter a nested run`);
       }
-    })(!this._cbs) : {};
+    })(!this._cbs);
     const _cbs = this._cbs = {};
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       try {
         cb();
         if (_cbs.coalesce) {
@@ -4854,18 +4927,6 @@ class Store extends BaseClass {
       } finally {
         this._cbs = null;
       }
-    } else {
-      cb();
-      if (_cbs.coalesce) {
-        _cbs.coalesce();
-      }
-      if (_cbs.sync) {
-        _cbs.sync();
-      }
-      if (_cbs.notify) {
-        _cbs.notify();
-      }
-      this._cbs = null;
     }
   }
 
@@ -4888,16 +4949,16 @@ class Store extends BaseClass {
 
   /** @internal */
   _schedule(name, cb) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`WarpDrive expects to schedule only when there is an active run`);
       }
-    })(!!this._cbs) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(!!this._cbs);
+    (test => {
       if (!test) {
         throw new Error(`WarpDrive expects only one flush per queue name, cannot schedule ${name}`);
       }
-    })(!this._cbs[name]) : {};
+    })(!this._cbs[name]);
     this._cbs[name] = cb;
   }
 
@@ -4917,7 +4978,7 @@ class Store extends BaseClass {
 
   /** @internal */
   _getAllPending() {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
+    {
       const all = [];
       const pending = this._requestCache._pending;
       pending.forEach(requests => {
@@ -4995,12 +5056,12 @@ class Store extends BaseClass {
       const cacheKeyManager = this.cacheKeyManager;
       opts.records = requestConfig.records.map(r => cacheKeyManager.getOrCreateRecordIdentifier(r));
     }
-    if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
+    {
       if (this.DISABLE_WAITER) {
         opts.disableTestWaiter = typeof requestConfig.disableTestWaiter === 'boolean' ? requestConfig.disableTestWaiter : true;
       }
     }
-    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_REQUESTS)) {
+    {
       if (getGlobalConfig().WarpDrive.debug.LOG_REQUESTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REQUESTS) {
         let options;
         try {
@@ -5015,13 +5076,12 @@ class Store extends BaseClass {
     const request = Object.assign({}, requestConfig, opts);
     const future = this.requestManager.request(request);
     future.onFinalize(() => {
-      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_REQUESTS)) {
+      {
         if (getGlobalConfig().WarpDrive.debug.LOG_REQUESTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REQUESTS) {
           // eslint-disable-next-line no-console
           console.log(`request: [[FINALIZE]] ${requestConfig.op && !requestConfig.url ? '(LEGACY) ' : ''}${requestConfig.op || '<unknown operation>'} ${requestConfig.url || '<empty url>'}  ${requestConfig.method || '<empty method>'}`);
         }
-      }
-      // skip flush for legacy belongsTo
+      } // skip flush for legacy belongsTo
       if (requestConfig.op === 'findBelongsTo' && !requestConfig.url) {
         return;
       }
@@ -5086,19 +5146,19 @@ class Store extends BaseClass {
   */
 
   createRecord(type, inputProperties, context) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       assertDestroyingStore(this, 'createRecord');
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`You need to pass a model name to the store's createRecord method`);
       }
-    })(type) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(type);
+    (test => {
       if (!test) {
         throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
       }
-    })(typeof type === 'string') : {};
+    })(typeof type === 'string');
 
     // This is wrapped in a `run.join` so that in test environments users do not need to manually wrap
     //   calls to `createRecord`. The run loop usage here is because we batch the joining and updating
@@ -5133,22 +5193,22 @@ class Store extends BaseClass {
       };
       if (resource.id) {
         const identifier = this.cacheKeyManager.peekResourceKey(resource);
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        (test => {
           if (!test) {
             throw new Error(`The id ${String(properties.id)} has already been used with another '${normalizedModelName}' record.`);
           }
-        })(!identifier) : {};
+        })(!identifier);
       }
       if (context?.lid) {
         const identifier = this.cacheKeyManager.peekResourceKey({
           lid: context?.lid
         });
         resource.lid = context.lid;
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        (test => {
           if (!test) {
             throw new Error(`The lid ${context.lid} has already been used with another '${identifier?.type}' record.`);
           }
-        })(!identifier) : {};
+        })(!identifier);
       }
       const identifier = this.cacheKeyManager.createIdentifierForNewRecord(resource);
       const cache = this.cache;
@@ -5172,16 +5232,16 @@ class Store extends BaseClass {
     @param {unknown} record
   */
   deleteRecord(record) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       assertDestroyingStore(this, 'deleteRecord');
     }
     const identifier = peekResourceKey(record);
     const cache = this.cache;
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`expected the record to be connected to a cache`);
       }
-    })(identifier) : {};
+    })(identifier);
     this._join(() => {
       cache.setIsDeleted(identifier, true);
       if (cache.isNew(identifier)) {
@@ -5202,7 +5262,7 @@ class Store extends BaseClass {
     @param {Model} record
   */
   unloadRecord(record) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       assertDestroyingStore(this, 'unloadRecord');
     }
     const identifier = peekResourceKey(record);
@@ -5250,19 +5310,19 @@ class Store extends BaseClass {
       // this is basically an "are we not empty" query.
       return isLoaded ? this._instanceCache.getRecord(stableIdentifier) : null;
     }
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       assertDestroyingStore(this, 'peekRecord');
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`You need to pass a model name to the store's peekRecord method`);
       }
-    })(identifier) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(identifier);
+    (test => {
       if (!test) {
         throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${String(identifier)}`);
       }
-    })(typeof identifier === 'string') : {};
+    })(typeof identifier === 'string');
     const type = normalizeModelName(identifier);
     const normalizedId = ensureStringId(id);
     const resource = {
@@ -5292,19 +5352,19 @@ class Store extends BaseClass {
   */
 
   peekAll(type) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       assertDestroyingStore(this, 'peekAll');
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`You need to pass a model name to the store's peekAll method`);
       }
-    })(type) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(type);
+    (test => {
       if (!test) {
         throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
       }
-    })(typeof type === 'string') : {};
+    })(typeof type === 'string');
     return this.recordArrayManager.liveArrayFor(normalizeModelName(type));
   }
 
@@ -5321,14 +5381,14 @@ class Store extends BaseClass {
   */
 
   unloadAll(type) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       assertDestroyedStoreOnly(this, 'unloadAll');
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${String(type)}`);
       }
-    })(!type || typeof type === 'string') : {};
+    })(!type || typeof type === 'string');
     this._join(() => {
       this._enableAsyncFlush = true;
       if (type === undefined) {
@@ -5475,7 +5535,7 @@ class Store extends BaseClass {
   */
 
   push(data) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       assertDestroyingStore(this, 'push');
     }
     const pushed = this._push(data, false);
@@ -5495,7 +5555,7 @@ class Store extends BaseClass {
     @return identifiers for the primary records that had data loaded
   */
   _push(jsonApiDoc, asyncFlush) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       assertDestroyingStore(this, '_push');
     }
     if (asyncFlush) {
@@ -5523,7 +5583,7 @@ class Store extends BaseClass {
     } = this._instanceCache;
     if (!cache) {
       cache = this._instanceCache.cache = this.createCache(this._instanceCache._storeWrapper);
-      if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+      {
         cache = this._instanceCache.cache = new CacheManager(cache);
       }
     }
@@ -5580,67 +5640,43 @@ function assertPrivateStore(store) {}
 function isPrivateStore(store) {
   return store;
 }
-if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA_SERVICE)) {
+{
   Store.prototype.getSchemaDefinitionService = function () {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`You must registerSchemaDefinitionService with the store to use custom model classes`);
       }
-    })(this._schema) : {};
-    deprecate(`Use \`store.schema\` instead of \`store.getSchemaDefinitionService()\``, false, {
-      id: 'ember-data:schema-service-updates',
-      until: '6.0',
-      for: 'ember-data',
-      since: {
-        available: '4.13',
-        enabled: '5.4'
-      }
-    });
+    })(this._schema);
+    console.warn(`Use \`store.schema\` instead of \`store.getSchemaDefinitionService()\``);
     return this._schema;
   };
   Store.prototype.registerSchemaDefinitionService = function (schema) {
-    deprecate(`Use \`store.createSchemaService\` instead of \`store.registerSchemaDefinitionService()\``, false, {
-      id: 'ember-data:schema-service-updates',
-      until: '6.0',
-      for: 'ember-data',
-      since: {
-        available: '4.13',
-        enabled: '5.4'
-      }
-    });
+    console.warn(`Use \`store.createSchemaService\` instead of \`store.registerSchemaDefinitionService()\``);
     this._schema = schema;
   };
   Store.prototype.registerSchema = function (schema) {
-    deprecate(`Use \`store.createSchemaService\` instead of \`store.registerSchema()\``, false, {
-      id: 'ember-data:schema-service-updates',
-      until: '6.0',
-      for: 'ember-data',
-      since: {
-        available: '4.13',
-        enabled: '5.4'
-      }
-    });
+    console.warn(`Use \`store.createSchemaService\` instead of \`store.registerSchema()\``);
     this._schema = schema;
   };
 }
 let assertDestroyingStore;
 let assertDestroyedStoreOnly;
-if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+{
   // eslint-disable-next-line @typescript-eslint/no-shadow
   assertDestroyingStore = function assertDestroyingStore(store, method) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Attempted to call store.${method}(), but the store instance has already been destroyed.`);
       }
-    })(!(store.isDestroying || store.isDestroyed)) : {};
+    })(!(store.isDestroying || store.isDestroyed));
   };
   // eslint-disable-next-line @typescript-eslint/no-shadow
   assertDestroyedStoreOnly = function assertDestroyedStoreOnly(store, method) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Attempted to call store.${method}(), but the store instance has already been destroyed.`);
       }
-    })(!store.isDestroyed) : {};
+    })(!store.isDestroyed);
   };
 }
 function isMaybeIdentifier(maybeIdentifier) {
@@ -5650,17 +5686,17 @@ function normalizeProperties(store, identifier, properties) {
   // assert here
   if (properties !== undefined) {
     if ('id' in properties) {
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      (test => {
         if (!test) {
           throw new Error(`expected id to be a string or null`);
         }
-      })(properties.id !== undefined) : {};
+      })(properties.id !== undefined);
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`You passed '${typeof properties}' as properties for record creation instead of an object.`);
       }
-    })(typeof properties === 'object' && properties !== null) : {};
+    })(typeof properties === 'object' && properties !== null);
     const {
       type
     } = identifier;
@@ -5676,7 +5712,7 @@ function normalizeProperties(store, identifier, properties) {
         const field = defs.get(prop);
         if (!field) continue;
         if (field.kind === 'hasMany') {
-          if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+          {
             assertRecordsPassedToHasMany(properties[prop]);
           }
           properties[prop] = extractIdentifiersFromRecords$1(properties[prop]);
@@ -5689,12 +5725,12 @@ function normalizeProperties(store, identifier, properties) {
   return properties;
 }
 function assertRecordsPassedToHasMany(records) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`You must pass an array of records to set a hasMany relationship`);
     }
-  })(Array.isArray(records)) : {};
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  })(Array.isArray(records));
+  (test => {
     if (!test) {
       throw new Error(`All elements of a hasMany relationship must be instances of Model, you passed ${records.map(r => `${typeof r}`).join(', ')}`);
     }
@@ -5707,7 +5743,7 @@ function assertRecordsPassedToHasMany(records) {
         return false;
       }
     });
-  }()) : {};
+  }());
 }
 function extractIdentifiersFromRecords$1(records) {
   return records.map(record => extractIdentifierFromRecord$1(record));
@@ -5731,6 +5767,7 @@ function extractIdentifierFromRecord$1(recordOrPromiseRecord) {
     Preloaded data can be attributes and relationships passed in either as IDs or as actual
     models.
   */
+
 function preloadData(store, identifier, preload) {
   const jsonPayload = {};
   //TODO(Igor) consider the polymorphic case
@@ -5758,20 +5795,20 @@ function preloadData(store, identifier, preload) {
 function preloadRelationship(schema, preloadValue) {
   const relatedType = schema.type;
   if (schema.kind === 'hasMany') {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error('You need to pass in an array to set a hasMany property on a record');
       }
-    })(Array.isArray(preloadValue)) : {};
+    })(Array.isArray(preloadValue));
     return {
       data: preloadValue.map(value => _convertPreloadRelationshipToJSON(value, relatedType))
     };
   }
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error('You should not pass in an array to set a belongsTo property on a record');
     }
-  })(!Array.isArray(preloadValue)) : {};
+  })(!Array.isArray(preloadValue));
   return {
     data: preloadValue ? _convertPreloadRelationshipToJSON(preloadValue, relatedType) : null
   };
@@ -5967,11 +6004,11 @@ class RecordReference {
     if (id !== null) {
       return this.store.findRecord(this.type, id);
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       {
         throw new Error(`Unable to fetch record of type ${this.type} without an id`);
       }
-    })() : {};
+    })();
   }
 
   /**
@@ -5993,11 +6030,11 @@ class RecordReference {
         reload: true
       });
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       {
         throw new Error(`Unable to fetch record of type ${this.type} without an id`);
       }
-    })() : {};
+    })();
   }
 }
 defineSignal(RecordReference.prototype, '_ref');
@@ -6089,36 +6126,33 @@ class ShimModelClass {
     });
   }
 }
-if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_REQUEST_METHODS)) {
+
+/////////////// IMPORTANT ///////////////////
+///// Move Module Augmentation Into The /////
+///// Legacy Package Once Removed Here  /////
+/////////////////////////////////////////////
+
+{
   Store.prototype.findRecord = function (resource, id, options) {
-    deprecate(`store.findRecord is deprecated. Use store.request instead.`, false, {
-      id: 'warp-drive:deprecate-legacy-request-methods',
-      until: '6.0',
-      for: '@warp-drive/core',
-      url: 'https://docs.warp-drive.io/api/@warp-drive/core/build-config/deprecations/variables/ENABLE_LEGACY_REQUEST_METHODS',
-      since: {
-        enabled: '5.7',
-        available: '5.7'
-      }
-    });
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    console.warn(`store.findRecord is deprecated. Use store.request instead.`);
+    (test => {
       if (!test) {
         throw new Error(`Attempted to call store.findRecord(), but the store instance has already been destroyed.`);
       }
-    })(!(this.isDestroying || this.isDestroyed)) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(!(this.isDestroying || this.isDestroyed));
+    (test => {
       if (!test) {
         throw new Error(`You need to pass a modelName or resource identifier as the first argument to the store's findRecord method`);
       }
-    })(resource) : {};
+    })(resource);
     if (isMaybeIdentifier(resource)) {
       options = id;
     } else {
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      (test => {
         if (!test) {
           throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${resource}`);
         }
-      })(typeof resource === 'string') : {};
+      })(typeof resource === 'string');
       const type = normalizeModelName(resource);
       const normalizedId = ensureStringId(id);
       resource = constructResource(type, normalizedId);
@@ -6151,31 +6185,22 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_REQUES
     });
   };
   Store.prototype.findAll = function (type, options = {}) {
-    deprecate(`store.findAll is deprecated. Use store.request instead.`, false, {
-      id: 'warp-drive:deprecate-legacy-request-methods',
-      until: '6.0',
-      for: '@warp-drive/core',
-      url: 'https://docs.warp-drive.io/api/@warp-drive/core/build-config/deprecations/variables/ENABLE_LEGACY_REQUEST_METHODS',
-      since: {
-        enabled: '5.7',
-        available: '5.7'
-      }
-    });
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    console.warn(`store.findAll is deprecated. Use store.request instead.`);
+    (test => {
       if (!test) {
         throw new Error(`Attempted to call store.findAll(), but the store instance has already been destroyed.`);
       }
-    })(!(this.isDestroying || this.isDestroyed)) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(!(this.isDestroying || this.isDestroyed));
+    (test => {
       if (!test) {
         throw new Error(`You need to pass a model name to the store's findAll method`);
       }
-    })(type) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(type);
+    (test => {
       if (!test) {
         throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
       }
-    })(typeof type === 'string') : {};
+    })(typeof type === 'string');
     const promise = this.request({
       op: 'findAll',
       data: {
@@ -6189,36 +6214,27 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_REQUES
     return promise.then(document => document.content);
   };
   Store.prototype.query = function (type, query, options = {}) {
-    deprecate(`store.query is deprecated. Use store.request instead.`, false, {
-      id: 'warp-drive:deprecate-legacy-request-methods',
-      until: '6.0',
-      for: '@warp-drive/core',
-      url: 'https://docs.warp-drive.io/api/@warp-drive/core/build-config/deprecations/variables/ENABLE_LEGACY_REQUEST_METHODS',
-      since: {
-        enabled: '5.7',
-        available: '5.7'
-      }
-    });
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    console.warn(`store.query is deprecated. Use store.request instead.`);
+    (test => {
       if (!test) {
         throw new Error(`Attempted to call store.query(), but the store instance has already been destroyed.`);
       }
-    })(!(this.isDestroying || this.isDestroyed)) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(!(this.isDestroying || this.isDestroyed));
+    (test => {
       if (!test) {
         throw new Error(`You need to pass a model name to the store's query method`);
       }
-    })(type) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(type);
+    (test => {
       if (!test) {
         throw new Error(`You need to pass a query hash to the store's query method`);
       }
-    })(query) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(query);
+    (test => {
       if (!test) {
         throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
       }
-    })(typeof type === 'string') : {};
+    })(typeof type === 'string');
     const promise = this.request({
       op: 'query',
       data: {
@@ -6233,36 +6249,27 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_REQUES
     return promise.then(document => document.content);
   };
   Store.prototype.queryRecord = function (type, query, options) {
-    deprecate(`store.queryRecord is deprecated. Use store.request instead.`, false, {
-      id: 'warp-drive:deprecate-legacy-request-methods',
-      until: '6.0',
-      for: '@warp-drive/core',
-      url: 'https://docs.warp-drive.io/api/@warp-drive/core/build-config/deprecations/variables/ENABLE_LEGACY_REQUEST_METHODS',
-      since: {
-        enabled: '5.7',
-        available: '5.7'
-      }
-    });
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    console.warn(`store.queryRecord is deprecated. Use store.request instead.`);
+    (test => {
       if (!test) {
         throw new Error(`Attempted to call store.queryRecord(), but the store instance has already been destroyed.`);
       }
-    })(!(this.isDestroying || this.isDestroyed)) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(!(this.isDestroying || this.isDestroyed));
+    (test => {
       if (!test) {
         throw new Error(`You need to pass a model name to the store's queryRecord method`);
       }
-    })(type) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(type);
+    (test => {
       if (!test) {
         throw new Error(`You need to pass a query hash to the store's queryRecord method`);
       }
-    })(query) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(query);
+    (test => {
       if (!test) {
         throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${type}`);
       }
-    })(typeof type === 'string') : {};
+    })(typeof type === 'string');
     const promise = this.request({
       op: 'queryRecord',
       data: {
@@ -6277,21 +6284,12 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_REQUES
     return promise.then(document => document.content);
   };
   Store.prototype.getReference = function (resource, id) {
-    deprecate(`store.getReference is deprecated. There is no direct replacement. For working with the cache and relationships, use the cache with the appropriate identifiers. To load, use store.request.`, false, {
-      id: 'warp-drive:deprecate-legacy-request-methods',
-      until: '6.0',
-      for: '@warp-drive/core',
-      url: 'https://docs.warp-drive.io/api/@warp-drive/core/build-config/deprecations/variables/ENABLE_LEGACY_REQUEST_METHODS',
-      since: {
-        enabled: '5.7',
-        available: '5.7'
-      }
-    });
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    console.warn(`store.getReference is deprecated. There is no direct replacement. For working with the cache and relationships, use the cache with the appropriate identifiers. To load, use store.request.`);
+    (test => {
       if (!test) {
         throw new Error(`Attempted to call store.getReference(), but the store instance has already been destroyed.`);
       }
-    })(!(this.isDestroying || this.isDestroyed)) : {};
+    })(!(this.isDestroying || this.isDestroyed));
     let resourceIdentifier;
     if (arguments.length === 1 && isMaybeIdentifier(resource)) {
       resourceIdentifier = resource;
@@ -6300,11 +6298,11 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_REQUES
       const normalizedId = ensureStringId(id);
       resourceIdentifier = constructResource(type, normalizedId);
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error('getReference expected to receive either a resource identifier or type and id as arguments');
       }
-    })(isMaybeIdentifier(resourceIdentifier)) : {};
+    })(isMaybeIdentifier(resourceIdentifier));
     const identifier = this.cacheKeyManager.getOrCreateRecordIdentifier(resourceIdentifier);
     const cache = upgradeInstanceCaches(this._instanceCache.__instances).reference;
     let reference = cache.get(identifier);
@@ -6315,56 +6313,38 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_REQUES
     return reference;
   };
   Store.prototype.modelFor = function (type) {
-    deprecate(`store.modelFor is deprecated, please use store.schema.fields({ type: '${type}' }) to access schema information instead.`, false, {
-      id: 'warp-drive:deprecate-legacy-request-methods',
-      until: '6.0',
-      for: '@warp-drive/core',
-      url: 'https://docs.warp-drive.io/api/@warp-drive/core/build-config/deprecations/variables/ENABLE_LEGACY_REQUEST_METHODS',
-      since: {
-        enabled: '5.7',
-        available: '5.7'
-      }
-    });
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    console.warn(`store.modelFor is deprecated, please use store.schema.fields({ type: '${type}' }) to access schema information instead.`);
+    (test => {
       if (!test) {
         throw new Error(`Attempted to call store.modelFor(), but the store instance has already been destroyed.`);
       }
-    })(!this.isDestroyed) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(!this.isDestroyed);
+    (test => {
       if (!test) {
         throw new Error(`You need to pass <type> to the store's modelFor method`);
       }
-    })(typeof type === 'string' && type.length) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(typeof type === 'string' && type.length);
+    (test => {
       if (!test) {
         throw new Error(`No model was found for '${type}' and no schema handles the type`);
       }
     })(this.schema.hasResource({
       type
-    })) : {};
+    }));
     return getShimClass(this, type);
   };
   Store.prototype.saveRecord = function (record, options = {}) {
-    deprecate(`store.saveRecord is deprecated, please use store.request to initiate a save request instead.`, false, {
-      id: 'warp-drive:deprecate-legacy-request-methods',
-      until: '6.0',
-      for: '@warp-drive/core',
-      url: 'https://docs.warp-drive.io/api/@warp-drive/core/build-config/deprecations/variables/ENABLE_LEGACY_REQUEST_METHODS',
-      since: {
-        enabled: '5.7',
-        available: '5.7'
-      }
-    });
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    console.warn(`store.saveRecord is deprecated, please use store.request to initiate a save request instead.`);
+    (test => {
       if (!test) {
         throw new Error(`Attempted to call store.saveRecord(), but the store instance has already been destroyed.`);
       }
-    })(!(this.isDestroying || this.isDestroyed)) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(!(this.isDestroying || this.isDestroyed));
+    (test => {
       if (!test) {
         throw new Error(`Unable to initiate save for a record in a disconnected state`);
       }
-    })(storeFor(record, true)) : {};
+    })(storeFor(record, true));
     const identifier = recordIdentifierFor(record);
     const cache = this.cache;
     if (!identifier) {
@@ -6372,11 +6352,11 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_REQUES
       // but just in case we reject here to prevent bad things.
       return Promise.reject(new Error(`Record Is Disconnected`));
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Cannot initiate a save request for an unloaded record: ${identifier.lid}`);
       }
-    })(this._instanceCache.recordIsLoaded(identifier)) : {};
+    })(this._instanceCache.recordIsLoaded(identifier));
     if (resourceIsFullyDeleted(this._instanceCache, identifier)) {
       return Promise.resolve(record);
     }
@@ -6528,14 +6508,14 @@ const CacheHandler = {
         activeRequest.priority = {
           blocking: true
         };
-        if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_REQUESTS)) {
+        {
           if (getGlobalConfig().WarpDrive.debug.LOG_REQUESTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REQUESTS) {
             log('request', '', 'DEDUPED', identifier.lid, 'blocking', '');
           }
         }
         return activeRequest.promise;
       }
-      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_REQUESTS)) {
+      {
         if (getGlobalConfig().WarpDrive.debug.LOG_REQUESTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REQUESTS) {
           log('request', '', 'ISSUED', identifier?.lid ?? context.request.url ?? context.request.op ?? '<unknown request>', 'blocking', '');
         }
@@ -6582,7 +6562,7 @@ const CacheHandler = {
           store.notifications.notify(identifier, 'state', null);
         });
       }
-      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_REQUESTS)) {
+      {
         if (getGlobalConfig().WarpDrive.debug.LOG_REQUESTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REQUESTS) {
           if (activeRequest && identifier) {
             log('request', '', 'DEDUPED', identifier.lid, activeRequest.priority.blocking ? 'blocking' : 'non-blocking', '');
@@ -6593,16 +6573,16 @@ const CacheHandler = {
       }
       store.requestManager._pending.set(context.id, promise);
     }
-    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_REQUESTS)) {
+    {
       if (getGlobalConfig().WarpDrive.debug.LOG_REQUESTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REQUESTS) {
         log('request', '', 'CACHE-HIT', identifier?.lid ?? context.request.url ?? context.request.op ?? '<unknown request>', 'cached', '');
       }
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Expected a peeked request to be present`);
       }
-    })(peeked) : {};
+    })(peeked);
     const shouldHydrate = context.request[EnableHydration] || false;
     context.setResponse(peeked.response);
     if ('error' in peeked) {
@@ -6626,11 +6606,11 @@ function maybeUpdateUiObjects(store, request, options, document) {
     identifier
   } = options;
   if (!document || !options.shouldHydrate) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`The CacheHandler expected response content but none was found`);
       }
-    })(!options.shouldHydrate) : {};
+    })(!options.shouldHydrate);
     return document ?? null;
   }
   if (identifier) {
@@ -6763,11 +6743,11 @@ function fetchContentAndHydrate(next, context, identifier, priority) {
   if (!isMut) {
     return promise;
   }
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Expected a mutation`);
     }
-  })(isMutation(context.request)) : {};
+  })(isMutation(context.request));
 
   // for mutations we need to enqueue the promise with the requestStateService
   // TODO should we enque a request per record in records?
@@ -6792,16 +6772,16 @@ function constructResource(type, id, lid) {
     if ('id' in resource) {
       resource.id = coerceId(resource.id);
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error('Expected either id or lid to be a valid string');
       }
-    })('id' in resource && isNonEmptyString(resource.id) || isNonEmptyString(resource.lid)) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })('id' in resource && isNonEmptyString(resource.id) || isNonEmptyString(resource.lid));
+    (test => {
       if (!test) {
         throw new Error('if id is present, the type must be a string');
       }
-    })(!('id' in resource) || typeof resource.type === 'string') : {};
+    })(!('id' in resource) || typeof resource.type === 'string');
     return resource;
   } else {
     const trueId = coerceId(id);
@@ -6813,11 +6793,11 @@ function constructResource(type, id, lid) {
       }
       throw new Error('Expected either id or lid to be a valid string');
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error('type must be a string');
       }
-    })(typeof type === 'string') : {};
+    })(typeof type === 'string');
     if (isNonEmptyString(lid)) {
       return {
         type,
@@ -6832,6 +6812,49 @@ function constructResource(type, id, lid) {
   }
 }
 
+/**
+  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_.
+
+  @public
+*/
+
 /**
  * The options for {@link createLegacyManyArray}
  *
@@ -6896,7 +6919,7 @@ function _MUTATE(target, receiver, prop, args, _SIGNAL) {
       {
         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();
@@ -6916,15 +6939,6 @@ function _MUTATE(target, receiver, prop, args, _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':
       {
@@ -6940,7 +6954,7 @@ function _MUTATE(target, receiver, prop, args, _SIGNAL) {
       {
         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();
@@ -6961,16 +6975,6 @@ function _MUTATE(target, receiver, prop, args, _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':
       {
@@ -6997,7 +7001,7 @@ function _MUTATE(target, receiver, prop, args, _SIGNAL) {
         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)) {
+          {
             // dedupe
             const current = new Set(adds);
             const unique = Array.from(current);
@@ -7006,15 +7010,10 @@ function _MUTATE(target, receiver, prop, args, _SIGNAL) {
             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);
@@ -7043,29 +7042,13 @@ function _MUTATE(target, receiver, prop, args, _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 => {
+      (test => {
         {
           throw new Error(`unable to convert ${prop} into a transaction that updates the cache state for this record array`);
         }
-      })() : {};
+      })();
   }
 }
 function notify() {
@@ -7075,11 +7058,11 @@ function reload(options) {
   const {
     manager
   } = this[Context];
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Expected the manager for ManyArray to implement reloadHasMany`);
     }
-  })(typeof manager.reloadHasMany === 'function') : {};
+  })(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);
 }
@@ -7087,11 +7070,11 @@ function createRecord(hash) {
   const {
     store
   } = this[Context];
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Expected modelName to be set`);
     }
-  })(this.modelName) : {};
+  })(this.modelName);
   const record = store.createRecord(this.modelName, hash);
   this.push(record);
   return record;
@@ -7100,7 +7083,7 @@ function destroyLegacyManyArray() {
   destroy.call(this, false);
 }
 function assertRecordPassedToHasMany(record) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`All elements of a hasMany relationship must be instances of Model, you passed ${typeof record}`);
     }
@@ -7111,7 +7094,7 @@ function assertRecordPassedToHasMany(record) {
     } catch {
       return false;
     }
-  }()) : {};
+  }());
 }
 function extractIdentifiersFromRecords(records) {
   return records.map(extractIdentifierFromRecord);
@@ -7126,18 +7109,8 @@ function assertNoDuplicates(collection, target, callback, reason) {
   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 \`<${identifier.type}:${identifier.id || identifier.lid}>.${collection.key}\`\n\t- ${Array.from(new Set(duplicates)).map(r => isResourceKey(r) ? r.lid : recordIdentifierFor(r).lid).sort((a, b) => a.localeCompare(b)).join('\n\t- ')}`, false, {
-        id: 'ember-data:deprecate-many-array-duplicates',
-        for: 'ember-data',
-        until: '6.0',
-        since: {
-          enabled: '5.3',
-          available: '4.13'
-        }
-      });
-    } else {
-      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 => isResourceKey(r) ? r.lid : recordIdentifierFor(r).lid).sort((a, b) => a.localeCompare(b)).join('\n\t- ')}`);
+    {
+      console.warn(`${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 => isResourceKey(r) ? r.lid : recordIdentifierFor(r).lid).sort((a, b) => a.localeCompare(b)).join('\n\t- ')}`);
     }
   }
 }
@@ -7200,11 +7173,11 @@ function mutate(collection, mutation, _SIGNAL) {
   const {
     manager
   } = collection[Context];
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Expected the manager for ManyArray to implement mutate`);
     }
-  })(typeof manager.mutate === 'function') : {};
+  })(typeof manager.mutate === 'function');
   manager.mutate(mutation);
   notifyInternalSignal(_SIGNAL);
 }
@@ -7685,11 +7658,11 @@ class RequestSubscription {
           this._latestRequest = reqState.refresh(true);
           break;
         default:
-          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          (test => {
             {
               throw new Error(`Invalid ${mode ? 'update mode' : '@autorefreshBehavior'} for <Request />: ${isNeverString(val)}`);
             }
-          })() : {};
+          })();
       }
       if (val !== 'refresh') {
         this._localRequest = this._latestRequest;
@@ -7776,11 +7749,11 @@ class RequestSubscription {
       request,
       query
     } = this._args;
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Cannot use both @request and @query args with the <Request> component`);
       }
-    })(!request || !query) : {};
+    })(!request || !query);
     const {
       _localRequest,
       _originalRequest,
@@ -7797,18 +7770,18 @@ class RequestSubscription {
     if (request) {
       return request;
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`You must provide either @request or an @query arg with the <Request> component`);
       }
-    })(query) : {};
+    })(query);
     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();
@@ -7820,10 +7793,6 @@ class RequestSubscription {
           cause: e
         });
       }
-    } else {
-      const request = this._request;
-      this._updateSubscriptions();
-      return request;
     }
   }
   static {
@@ -8206,21 +8175,21 @@ function createRequestState(future) {
   promiseState._request = future;
   // @ts-expect-error - we still attach it for PendingState
   promiseState.reload = () => {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Cannot reload a request that is still pending. Await or abort the original request first.`);
       }
-    })(!promiseState.isPending) : {};
+    })(!promiseState.isPending);
     return performRefresh(future.requester, promiseState.request, true);
   };
 
   // @ts-expect-error - we still attach it for PendingState
   promiseState.refresh = (usePolicy = false) => {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Cannot refresh a request that is still pending. Await or abort the original request first.`);
       }
-    })(!promiseState.isPending) : {};
+    })(!promiseState.isPending);
     return performRefresh(future.requester, promiseState.request, usePolicy === true ? null : false);
   };
   if (state) {
@@ -8334,18 +8303,18 @@ function getRequestState(future) {
   return state;
 }
 function getAliasField(context) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     {
       throw new Error(`Alias field access is not implemented`);
     }
-  })() : {};
+  })();
 }
 function setAliasField(context) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     {
       throw new Error(`Alias field setting is not implemented`);
     }
-  })() : {};
+  })();
   return false;
 }
 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']);
@@ -8375,11 +8344,11 @@ function safeForEach(instance, arr, store, callback, target) {
   }
   // clone to prevent mutation
   arr = arr.slice();
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error('`forEach` expects a function as first argument.');
     }
-  })(typeof callback === 'function') : {};
+  })(typeof callback === 'function');
 
   // because we retrieveLatest above we need not worry if array is mutated during iteration
   // by unloadRecord/rollbackAttributes
@@ -8477,11 +8446,11 @@ class ManagedArray {
             // the special string "@hash" which tells us to treat field.type as a hashFn name with which
             // to calc the type.
             if (typePath === '@hash') {
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              (test => {
                 if (!test) {
                   throw new Error(`Expected the field to define a hashFn as its type`);
                 }
-              })(field.type) : {};
+              })(field.type);
               const hashFn = schema.hashFn({
                 type: field.type
               });
@@ -8489,18 +8458,18 @@ class ManagedArray {
               objectType = hashFn(rawValue, null, null);
             } else {
               objectType = rawValue[typePath];
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              (test => {
                 if (!test) {
                   throw new Error(`Expected the type path for the field to be a value on the raw object`);
                 }
-              })(typePath && objectType && typeof objectType === 'string') : {};
+              })(typePath && objectType && typeof objectType === 'string');
             }
           } else {
-            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+            (test => {
               if (!test) {
                 throw new Error(`A non-polymorphic SchemaArrayField must provide a SchemaObject type in its definition`);
               }
-            })(field.type) : {};
+            })(field.type);
             objectType = field.type;
           }
 
@@ -8525,37 +8494,37 @@ class ManagedArray {
             // and, we likely should lookup the associated field and throw an error IF
             // the given field does not exist OR
             // the field is anything other than a GenericField or LegacyAttributeField.
-            if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+            {
               const isPathKeyMode = KeyMode !== '@identity' && KeyMode !== '@index';
               if (isPathKeyMode) {
-                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                (test => {
                   if (!test) {
                     throw new Error('mode must be a string');
                   }
-                })(typeof KeyMode === 'string' && KeyMode !== '') : {};
+                })(typeof KeyMode === 'string' && KeyMode !== '');
                 const modeField = schema.fields({
                   type: objectType
                 }).get(KeyMode);
-                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                (test => {
                   if (!test) {
                     throw new Error('field must exist in schema');
                   }
-                })(modeField) : {};
-                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                })(modeField);
+                (test => {
                   if (!test) {
                     throw new Error('field must be a GenericField or LegacyAttributeField');
                   }
-                })(modeField.kind === 'field' || modeField.kind === 'attribute') : {};
+                })(modeField.kind === 'field' || modeField.kind === 'attribute');
               }
             }
             schemaObjectKeyValue = KeyMode === '@identity' ? rawValue : KeyMode === '@index' ? index : rawValue[KeyMode];
           }
           if (!schemaObjectKeyValue && schemaObjectKeyValue !== 0) {
-            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+            (test => {
               {
                 throw new Error(`Unexpected out of bounds access on SchemaArray`);
               }
-            })() : {};
+            })();
             return undefined;
           }
           const recordRef = ManagedRecordRefs.get(schemaObjectKeyValue);
@@ -8652,11 +8621,11 @@ class ManagedArray {
           if (context.path) {
             errorPath = context.path[context.path.length - 1];
           }
-          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          (test => {
             {
               throw new Error(`Cannot set ${String(prop)} on ${errorPath} because the ReactiveResource is not editable`);
             }
-          })() : {};
+          })();
           return false;
         }
         if (prop === 'identifier') {
@@ -8715,7 +8684,7 @@ const desc = {
   get: function () {
     // here to support computed chains
     // and {{#each}}
-    if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_COMPUTED_CHAINS)) {
+    {
       return this;
     }
   }
@@ -8798,11 +8767,11 @@ function setArrayField(context) {
   const rawValue = value === null ? null : field.type ? value.map(item => transform.serialize(item, field.options ?? null, record)) : value?.slice();
   cache.setAttr(context.resourceKey, context.path, rawValue);
   if (peeked) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Expected the peekManagedArray for ${field.kind} to return a ManagedArray`);
       }
-    })(ARRAY_SIGNAL in peeked) : {};
+    })(ARRAY_SIGNAL in peeked);
     const arrSignal = peeked[ARRAY_SIGNAL];
     arrSignal.isStale = true;
     // TODO run array destroy?
@@ -8853,11 +8822,11 @@ function getBelongsToField(context) {
   }
 
   // FIXME move this to a "LegacyMode" make this part of "PolarisMode"
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Can only use belongsTo fields when the resource is in legacy mode`);
     }
-  })(context.legacy) : {};
+  })(context.legacy);
   return schema._kind('@legacy', 'belongsTo').get(store, context.record, resourceKey, field);
 }
 function setBelongsToField(context) {
@@ -8867,28 +8836,28 @@ function setBelongsToField(context) {
   const {
     schema
   } = store;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Can only mutate belongsTo fields when the resource is in legacy mode`);
     }
-  })(context.legacy) : {};
+  })(context.legacy);
   schema._kind('@legacy', 'belongsTo').set(store, context.record, context.resourceKey, context.field, context.value);
   return true;
 }
 function getCollectionField(context) {
   entangleSignal(context.signals, context.record, context.path.at(-1), null);
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     {
       throw new Error(`Accessing collection fields is not yet implemented`);
     }
-  })() : {};
+  })();
 }
 function setCollectionField(context) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     {
       throw new Error(`Setting collection fields is not yet implemented`);
     }
-  })() : {};
+  })();
   return false;
 }
 function getDerivedField(context) {
@@ -8898,11 +8867,11 @@ function getDerivedField(context) {
   return schema.derivation(context.field)(context.record, context.field.options ?? null, context.field.name);
 }
 function setDerivedField(context) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     {
       throw new Error(`ILLEGAL SET: Cannot set '${context.path.join('.')}' on '${context.resourceKey.type}' as ${context.field.kind} fields are not mutable`);
     }
-  })() : {};
+  })();
   return false;
 }
 function getGenericField(context) {
@@ -8977,11 +8946,11 @@ class ManyArrayManager {
   reloadHasMany(key, options) {
     // FIXME field needs to use sourceKey
     const field = this.store.schema.fields(this.identifier).get(key);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Expected a hasMany field for ${key}`);
       }
-    })(field?.kind === 'hasMany') : {};
+    })(field?.kind === 'hasMany');
     const cacheOptions = options ? extractCacheOptions(options) : {
       reload: true
     };
@@ -9009,11 +8978,11 @@ class ManyArrayManager {
 }
 function getRelatedLink(resource) {
   const related = resource.links?.related;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Expected a related link`);
     }
-  })(related) : {};
+  })(related);
   return typeof related === 'object' ? related.href : related;
 }
 function extractCacheOptions(options) {
@@ -9074,27 +9043,27 @@ function getHasManyField(context) {
     signal.value = managedArray;
     return managedArray;
   }
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
     }
-  })(context.legacy) : {};
+  })(context.legacy);
   return store.schema._kind('@legacy', 'hasMany').get(store, context.record, context.resourceKey, field);
 }
 function setHasManyField(context) {
   const {
     store
   } = context;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
     }
-  })(context.legacy) : {};
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  })(context.legacy);
+  (test => {
     if (!test) {
       throw new Error(`You must pass an array of records to set a hasMany relationship`);
     }
-  })(Array.isArray(context.value)) : {};
+  })(Array.isArray(context.value));
   store.schema._kind('@legacy', 'hasMany').set(store, context.record, context.resourceKey, context.field, context.value);
   return true;
 }
@@ -9108,21 +9077,21 @@ function getHashField(context) {
     schema,
     cache
   } = context.store;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Cannot use a ${field.kind} directly on a resource.`);
     }
-  })(Array.isArray(path) && path.length > 1) : {};
+  })(Array.isArray(path) && path.length > 1);
   const realPath = path.slice(0, -1);
   const rawData = context.editable ? cache.getAttr(resourceKey, realPath) : cache.getRemoteAttr(resourceKey, realPath);
   return schema.hashFn(field)(rawData, field.options ?? null, field.name ?? null);
 }
 function setHashField(context) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     {
       throw new Error(`ILLEGAL SET: Cannot set '${Array.isArray(context.path) ? context.path.join('.') : context.path}' on '${context.resourceKey.type}' as ${context.field.kind} fields are not mutable`);
     }
-  })() : {};
+  })();
   return false;
 }
 function getIdentityField(context) {
@@ -9135,18 +9104,18 @@ function setIdentityField(context) {
     resourceKey,
     store
   } = context;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Expected to receive a string id`);
     }
-  })(typeof value === 'string' && value.length) : {};
+  })(typeof value === 'string' && value.length);
   const normalizedId = String(value);
   const didChange = normalizedId !== resourceKey.id;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Cannot set ${resourceKey.type} record's id to ${normalizedId}, because id is already ${resourceKey.id}`);
     }
-  })(!didChange || resourceKey.id === null) : {};
+  })(!didChange || resourceKey.id === null);
   if (normalizedId !== null && didChange) {
     store._instanceCache.setRecordId(resourceKey, normalizedId);
     store.notifications.notify(resourceKey, 'identity', null);
@@ -9264,11 +9233,11 @@ class ManagedObject {
         return Reflect.get(target, prop, receiver);
       },
       set(target, prop, value, receiver) {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        (test => {
           if (!test) {
             throw new Error(`Cannot set read-only property '${String(prop)}' on ManagedObject`);
           }
-        })(context.editable) : {};
+        })(context.editable);
 
         // since objects function as dictionaries, we can't defer to schema/data before extensions
         // unless the prop is in the existing data.
@@ -9411,12 +9380,9 @@ class ResourceRelationship {
     this.lid = rawValue.lid ?? rawValue.links?.self ?? `relationship:${resourceKey.lid}.${name}`;
     this.data = rawValue.data ? store.peekRecord(rawValue.data) : null;
     this.name = name;
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       this.links = Object.freeze(Object.assign({}, rawValue.links));
       this.meta = Object.freeze(Object.assign({}, rawValue.meta));
-    } else {
-      this.links = rawValue.links ?? {};
-      this.meta = rawValue.meta ?? {};
     }
     this[Context] = context;
   }
@@ -9449,11 +9415,11 @@ function getResourceField(context) {
   return new ResourceRelationship(context);
 }
 function setResourceField(context) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     {
       throw new Error(`setting resource relationships is not yet supported`);
     }
-  })() : {};
+  })();
   return false;
 }
 function setSchemaArrayField(context) {
@@ -9462,11 +9428,11 @@ function setSchemaArrayField(context) {
   const peeked = fieldSignal?.value;
   context.store.cache.setAttr(context.resourceKey, context.path, arrayValue);
   if (peeked) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Expected the peekManagedArray for ${context.field.kind} to return a ManagedArray`);
       }
-    })(ARRAY_SIGNAL in peeked) : {};
+    })(ARRAY_SIGNAL in peeked);
     const arrSignal = peeked[ARRAY_SIGNAL];
     arrSignal.isStale = true;
     if (!Array.isArray(arrayValue)) {
@@ -9512,11 +9478,11 @@ function getSchemaObjectField(context) {
     // the special string "@hash" which tells us to treat field.type as a hashFn name with which
     // to calc the type.
     if (typePath === '@hash') {
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      (test => {
         if (!test) {
           throw new Error(`Expected the field to define a hashFn as its type`);
         }
-      })(field.type) : {};
+      })(field.type);
       const hashFn = schema.hashFn({
         type: field.type
       });
@@ -9524,18 +9490,18 @@ function getSchemaObjectField(context) {
       objectType = hashFn(rawValue, null, null);
     } else {
       objectType = rawValue[typePath];
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      (test => {
         if (!test) {
           throw new Error(`Expected the type path for the field to be a value on the raw object`);
         }
-      })(typePath && objectType && typeof objectType === 'string') : {};
+      })(typePath && objectType && typeof objectType === 'string');
     }
   } else {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`A non-polymorphic SchemaObjectField must provide a SchemaObject type in its definition`);
       }
-    })(field.type) : {};
+    })(field.type);
     objectType = field.type;
   }
   const hashField = schema.resource({
@@ -9577,11 +9543,11 @@ function setSchemaObjectField(context) {
   } = context;
   let newValue = value;
   if (value !== null) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Expected value to be an object`);
       }
-    })(typeof value === 'object') : {};
+    })(typeof value === 'object');
     newValue = {
       ...value
     };
@@ -9591,11 +9557,11 @@ function setSchemaObjectField(context) {
     });
     for (const key of Object.keys(newValue)) {
       if (!schemaFields.has(key)) {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        (test => {
           {
             throw new Error(`Field ${key} does not exist on schema object ${context.field.type}`);
           }
-        })() : {};
+        })();
         return false;
       }
     }
@@ -9814,11 +9780,11 @@ class ReactiveResource {
               if (field?.kind === 'array' || field?.kind === 'schema-array') {
                 const peeked = signal?.value;
                 if (peeked) {
-                  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                  (test => {
                     if (!test) {
                       throw new Error(`Expected the peekManagedArray for ${field.kind} to return a ManagedArray`);
                     }
-                  })(ARRAY_SIGNAL in peeked) : {};
+                  })(ARRAY_SIGNAL in peeked);
                   const arrSignal = peeked[ARRAY_SIGNAL];
                   notifyInternalSignal(arrSignal);
                 }
@@ -9839,11 +9805,11 @@ class ReactiveResource {
               if (isEmbedded) return; // base paths never apply to embedded records
 
               const field = cacheFields.get(key);
-              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              (test => {
                 if (!test) {
                   throw new Error(`Expected relationship ${key} to be the name of a field`);
                 }
-              })(field) : {};
+              })(field);
               if (field.kind === 'belongsTo') {
                 // TODO determine what LOGGING flag to wrap this in if any
                 // console.log(`Notification for ${key} on ${identifier.type}`, proxy);
@@ -9863,22 +9829,22 @@ class ReactiveResource {
                   }
                   return;
                 }
-                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                (test => {
                   if (!test) {
                     throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
                   }
-                })(context.legacy) : {};
+                })(context.legacy);
                 if (schema._kind('@legacy', 'hasMany').notify(context.store, proxy, resourceKey, field)) {
-                  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                  (test => {
                     if (!test) {
                       throw new Error(`Expected options to exist on relationship meta`);
                     }
-                  })(field.options) : {};
-                  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                  })(field.options);
+                  (test => {
                     if (!test) {
                       throw new Error(`Expected async to exist on relationship meta options`);
                     }
-                  })('async' in field.options) : {};
+                  })('async' in field.options);
                   if (field.options.async) {
                     const signal = signals.get(key);
                     if (signal) {
@@ -9909,11 +9875,11 @@ class ReactiveResource {
       },
       getOwnPropertyDescriptor(target, prop) {
         const schemaForField = prop === identityField?.name ? identityField : fields.get(prop);
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        (test => {
           if (!test) {
             throw new Error(`No field named ${String(prop)} on ${resourceKey.type}`);
           }
-        })(schemaForField) : {};
+        })(schemaForField);
         if (isNonEnumerableProp(prop)) {
           return {
             writable: false,
@@ -10067,19 +10033,19 @@ class ReactiveResource {
 
           // too many things check for random symbols
           if (typeof prop === 'symbol') return undefined;
-          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          (test => {
             {
               throw new Error(`No field named ${String(prop)} on ${context.path ? context.value : resourceKey.type}`);
             }
-          })() : {};
+          })();
           return undefined;
         }
         const field = maybeField.kind === 'alias' ? maybeField.options : maybeField;
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        (test => {
           if (!test) {
             throw new Error(`Alias fields cannot alias '@id' '@local' '@hash' or 'derived' fields`);
           }
-        })(maybeField.kind !== 'alias' || !['@id', '@local', '@hash', 'derived'].includes(maybeField.options.kind)) : {};
+        })(maybeField.kind !== 'alias' || !['@id', '@local', '@hash', 'derived'].includes(maybeField.options.kind));
         /**
          * Prop Array is the path from a resource to the field including
          * intermediate "links" on arrays,objects,schema-arrays and schema-objects.
@@ -10147,11 +10113,11 @@ class ReactiveResource {
           return true;
         }
         if (!context.editable) {
-          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          (test => {
             {
               throw new Error(`Cannot set ${String(prop)} on ${context.path !== null ? context.value : resourceKey.type} because the ReactiveResource is not editable`);
             }
-          })() : {};
+          })();
           return false;
         }
         const maybeField = prop === identityField?.name ? identityField : fields.get(prop);
@@ -10160,19 +10126,19 @@ class ReactiveResource {
           if (isExtensionProp(extensions, prop)) {
             return performExtensionSet(receiver, extensions, signals, prop, value);
           }
-          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          (test => {
             {
               throw new Error(`There is no settable field named ${String(prop)} on ${type}`);
             }
-          })() : {};
+          })();
           return false;
         }
         const field = maybeField.kind === 'alias' ? maybeField.options : maybeField;
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        (test => {
           if (!test) {
             throw new Error(`Alias fields cannot alias '@id' '@local' '@hash' or 'derived' fields`);
           }
-        })(maybeField.kind !== 'alias' || !['@id', '@local', '@hash', 'derived'].includes(maybeField.options.kind)) : {};
+        })(maybeField.kind !== 'alias' || !['@id', '@local', '@hash', 'derived'].includes(maybeField.options.kind));
         /**
          * Prop Array is the path from a resource to the field including
          * intermediate "links" on arrays,objects,schema-arrays and schema-objects.
@@ -10234,7 +10200,7 @@ class ReactiveResource {
         }
       }
     });
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       Object.defineProperty(this, '__SHOW_ME_THE_DATA_(debug mode only)__', {
         enumerable: false,
         configurable: true,
@@ -10304,11 +10270,11 @@ function _DESTROY(record) {
   // resource is destroyed.
 }
 function assertNeverField(identifier, field, path) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     {
       throw new Error(`Cannot use unknown field kind ${field.kind} on <${identifier.type}>.${Array.isArray(path) ? path.join('.') : path}`);
     }
-  })() : {};
+  })();
   return false;
 }
 
@@ -10356,11 +10322,11 @@ function commit(record) {
 function instantiateRecord(store, identifier, createArgs) {
   const schema = store.schema;
   const resourceSchema = schema.resource(identifier);
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Expected a resource schema`);
     }
-  })(isResourceSchema(resourceSchema)) : {};
+  })(isResourceSchema(resourceSchema));
   const legacy = resourceSchema?.legacy ?? false;
   const editable = legacy;
   const record = new ReactiveResource({
@@ -10379,11 +10345,11 @@ function instantiateRecord(store, identifier, createArgs) {
   return record;
 }
 function assertReactiveResource(record) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error('Expected a ReactiveResource');
     }
-  })(record && typeof record === 'object' && Destroy in record) : {};
+  })(record && typeof record === 'object' && Destroy in record);
 }
 function teardownRecord(record) {
   assertReactiveResource(record);
@@ -10416,11 +10382,11 @@ function _constructor(record) {
   return state._constructor = state._constructor || {
     name: `ReactiveResource<${recordIdentifierFor(record).type}>`,
     get modelName() {
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      (test => {
         {
           throw new Error(`record.constructor.modelName is not available outside of legacy mode`);
         }
-      })() : {};
+      })();
       return undefined;
     }
   };
@@ -10447,11 +10413,11 @@ function processExtension(extension) {
   for (const key of Object.getOwnPropertyNames(baseFeatures)) {
     if (BannedKeys.includes(key)) continue;
     const decl = Object.getOwnPropertyDescriptor(baseFeatures, key);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Expected to find a declaration for ${key} on extension ${name}`);
       }
-    })(decl) : {};
+    })(decl);
     if (decl.value) {
       const {
         value
@@ -10488,11 +10454,11 @@ function processExtension(extension) {
       });
       continue;
     }
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       {
         throw new Error(`The feature ${key} on extension ${name} is of an unknown variety.`);
       }
-    })() : {};
+    })();
   }
   return {
     kind,
@@ -10502,11 +10468,11 @@ function processExtension(extension) {
 }
 function getExt(extCache, type, extName) {
   const ext = extCache[type].get(extName);
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`expected to have an extension named ${String(extName)} available for ${type}s`);
     }
-  })(ext) : {};
+  })(ext);
   return ext?.features ?? null;
 }
 function hasObjectSchema(field) {
@@ -10618,16 +10584,16 @@ function withDefaults(schema) {
 const fromIdentity = (record, options, key) => {
   const context = record[Context];
   const identifier = context.resourceKey;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`Cannot compute @identity for a record without an identifier`);
     }
-  })(identifier) : {};
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  })(identifier);
+  (test => {
     if (!test) {
       throw new Error(`Expected to receive a key to compute @identity, but got ${String(options)}`);
     }
-  })(options?.key && ['lid', 'id', 'type', '^'].includes(options.key)) : {};
+  })(options?.key && ['lid', 'id', 'type', '^'].includes(options.key));
   return options.key === '^' ? identifier : identifier[options.key];
 };
 fromIdentity[Type] = '@identity';
@@ -10717,69 +10683,69 @@ class SchemaService {
   transformation(field) {
     const kind = 'kind' in field ? field.kind : '<unknown kind>';
     const name = 'name' in field ? field.name : '<unknown name>';
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`'${kind}' fields cannot be transformed. Only fields of kind 'field' 'object' or 'array' can specify a transformation. Attempted to find '${field.type ?? '<unknown type>'}' on field '${name}'.`);
       }
-    })(!('kind' in field) || ['field', 'object', 'array'].includes(kind)) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(!('kind' in field) || ['field', 'object', 'array'].includes(kind));
+    (test => {
       if (!test) {
         throw new Error(`Expected the '${kind}' field '${name}' to specify a transformation via 'field.type', but none was present`);
       }
-    })(field.type) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(field.type);
+    (test => {
       if (!test) {
         throw new Error(`No transformation registered with name '${field.type}' for '${kind}' field '${name}'`);
       }
-    })(this._transforms.has(field.type)) : {};
+    })(this._transforms.has(field.type));
     return this._transforms.get(field.type);
   }
   derivation(field) {
     const kind = 'kind' in field ? field.kind : '<unknown kind>';
     const name = 'name' in field ? field.name : '<unknown name>';
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`The '${kind}' field '${name}' is not derived and so cannot be used to lookup a derivation`);
       }
-    })(!('kind' in field) || kind === 'derived') : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(!('kind' in field) || kind === 'derived');
+    (test => {
       if (!test) {
         throw new Error(`Expected the '${kind}' field '${name}' to specify a derivation via 'field.type', but no value was present`);
       }
-    })(field.type) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(field.type);
+    (test => {
       if (!test) {
         throw new Error(`No '${field.type}' derivation registered for use by the '${kind}' field '${name}'`);
       }
-    })(this._derivations.has(field.type)) : {};
+    })(this._derivations.has(field.type));
     return this._derivations.get(field.type);
   }
   hashFn(field) {
     const kind = 'kind' in field ? field.kind : '<unknown kind>';
     const name = 'name' in field ? field.name : '<unknown name>';
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`The '${kind}' field '${name}' is not a HashField and so cannot be used to lookup a hash function`);
       }
-    })(!('kind' in field) || kind === '@hash') : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(!('kind' in field) || kind === '@hash');
+    (test => {
       if (!test) {
         throw new Error(`Expected the '${kind}' field '${name}' to specify a hash function via 'field.type', but no value was present`);
       }
-    })(field.type) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    })(field.type);
+    (test => {
       if (!test) {
         throw new Error(`No '${field.type}' hash function is registered for use by the '${kind}' field '${name}'`);
       }
-    })(this._hashFns.has(field.type)) : {};
+    })(this._hashFns.has(field.type));
     return this._hashFns.get(field.type);
   }
   resource(resource) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`No resource registered with name '${resource.type}'`);
       }
-    })(this._schemas.has(resource.type)) : {};
+    })(this._schemas.has(resource.type));
     return this._schemas.get(resource.type).original;
   }
   registerResources(schemas) {
@@ -10792,13 +10758,13 @@ class SchemaService {
     const relationships = {};
     const attributes = {};
     for (const field of schema.fields) {
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      (test => {
         if (!test) {
           throw new Error(`${field.kind} is not valid inside a ResourceSchema's fields.`);
         }
       })(
       // @ts-expect-error we are checking for mistakes at runtime
-      field.kind !== '@id' && field.kind !== '@hash') : {};
+      field.kind !== '@id' && field.kind !== '@hash');
       fields.set(field.name, field);
       if (field.kind === 'attribute') {
         attributes[field.name] = field;
@@ -10868,11 +10834,11 @@ class SchemaService {
     this._derivations.set(derivation[Type], makeCachedDerivation(derivation));
   }
   CAUTION_MEGA_DANGER_ZONE_registerExtension(extension) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`an extension named ${extension.name} for ${extension.kind} already exists!`);
       }
-    })(!this._extensions[extension.kind].has(extension.name)) : {};
+    })(!this._extensions[extension.kind].has(extension.name));
     this._extensions[extension.kind].set(extension.name, processExtension(extension));
   }
   CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource) {
@@ -10901,11 +10867,11 @@ class SchemaService {
    * @internal
    */
   _registerMode(mode, kinds) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Mode '${mode}' is already registered`);
       }
-    })(!this._modes.has(mode)) : {};
+    })(!this._modes.has(mode));
     this._modes.set(mode, kinds);
   }
 
@@ -10921,17 +10887,17 @@ class SchemaService {
    * @internal
    */
   _kind(mode, kind) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Mode '${mode}' is not registered`);
       }
-    })(this._modes.has(mode)) : {};
+    })(this._modes.has(mode));
     const kinds = this._modes.get(mode);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`Kind '${kind}' is not registered for mode '${mode}'`);
       }
-    })(kinds[kind]) : {};
+    })(kinds[kind]);
     return kinds[kind];
   }
 
@@ -10948,11 +10914,11 @@ class SchemaService {
     type
   }) {
     const schema = this._schemas.get(type);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`No schema defined for ${type}`);
       }
-    })(schema) : {};
+    })(schema);
     if (!schema.finalized) {
       finalizeResource(this, schema);
     }
@@ -10962,11 +10928,11 @@ class SchemaService {
     type
   }) {
     const schema = this._schemas.get(type);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`No schema defined for ${type}`);
       }
-    })(schema) : {};
+    })(schema);
     if (!schema.finalized) {
       finalizeResource(this, schema);
     }
@@ -10976,19 +10942,11 @@ class SchemaService {
     return this._schemas.has(resource.type);
   }
 }
-if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA_SERVICE)) {
+{
   SchemaService.prototype.attributesDefinitionFor = function ({
     type
   }) {
-    deprecate(`Use \`schema.fields({ type })\` instead of \`schema.attributesDefinitionFor({ type })\``, false, {
-      id: 'ember-data:schema-service-updates',
-      until: '6.0',
-      for: 'ember-data',
-      since: {
-        available: '4.13',
-        enabled: '5.4'
-      }
-    });
+    console.warn(`Use \`schema.fields({ type })\` instead of \`schema.attributesDefinitionFor({ type })\``);
     const schema = this._schemas.get(type);
     if (!schema) {
       throw new Error(`No schema defined for ${type}`);
@@ -10998,15 +10956,7 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA
   SchemaService.prototype.relationshipsDefinitionFor = function ({
     type
   }) {
-    deprecate(`Use \`schema.fields({ type })\` instead of \`schema.relationshipsDefinitionFor({ type })\``, false, {
-      id: 'ember-data:schema-service-updates',
-      until: '6.0',
-      for: 'ember-data',
-      since: {
-        available: '4.13',
-        enabled: '5.4'
-      }
-    });
+    console.warn(`Use \`schema.fields({ type })\` instead of \`schema.relationshipsDefinitionFor({ type })\``);
     const schema = this._schemas.get(type);
     if (!schema) {
       throw new Error(`No schema defined for ${type}`);
@@ -11014,15 +10964,7 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA
     return schema.relationships;
   };
   SchemaService.prototype.doesTypeExist = function (type) {
-    deprecate(`Use \`schema.hasResource({ type })\` instead of \`schema.doesTypeExist(type)\``, false, {
-      id: 'ember-data:schema-service-updates',
-      until: '6.0',
-      for: 'ember-data',
-      since: {
-        available: '4.13',
-        enabled: '5.4'
-      }
-    });
+    console.warn(`Use \`schema.hasResource({ type })\` instead of \`schema.doesTypeExist(type)\``);
     return this._schemas.has(type);
   };
 }
@@ -11051,12 +10993,12 @@ function finalizeResource(schema, resource) {
   const seen = new Set();
   for (const traitName of resource.traits) {
     const trait = schema._traits.get(traitName);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    (test => {
       if (!test) {
         throw new Error(`The trait ${traitName} MUST be supplied before the resource ${resource.original.type} can be finalized for use.`);
       }
-    })(trait) : {};
-    walkTrait(schema, trait, fields, seen, resource.original.type, macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? [] : null);
+    })(trait);
+    walkTrait(schema, trait, fields, seen, resource.original.type, []);
   }
   mergeMap(fields, resource.fields);
   resource.fields = fields;
@@ -11070,11 +11012,11 @@ function getCacheFields(resource) {
   const cacheFields = new Map();
   for (const [key, value] of fields) {
     if (isNonIdentityCacheableField(value)) {
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      (test => {
         if (!test) {
           throw new Error(`The sourceKey '${value.sourceKey}' for the field '${key}' on ${resource.original.type} is invalid because it matches the name of an existing field`);
         }
-      })(!value.sourceKey || value.sourceKey === key || !fields.has(value.sourceKey)) : {};
+      })(!value.sourceKey || value.sourceKey === key || !fields.has(value.sourceKey));
       const cacheKey = getFieldCacheKeyStrict(value);
       cacheFields.set(cacheKey, value);
     }
@@ -11084,14 +11026,14 @@ function getCacheFields(resource) {
 function walkTrait(schema, trait, fields, seen, type, debugPath) {
   if (seen.has(trait)) {
     // if the trait is in the current path, we throw a cycle error in dev.
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       if (debugPath.includes(trait.name)) {
         throw new Error(`CycleError: The Trait '${trait.name}' utilized by the Resource '${type}' includes the following circular reference "${debugPath.join(' > ')} > ${trait.name}"`);
       }
     }
     return;
   }
-  const ownPath = macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? [...debugPath, trait.name] : null;
+  const ownPath = [...debugPath, trait.name];
 
   // immediately mark as seen to prevent cycles
   // further down the tree from looping back
@@ -11101,14 +11043,8 @@ function walkTrait(schema, trait, fields, seen, type, debugPath) {
   if (trait.traits?.length) {
     for (const traitName of trait.traits) {
       const subtrait = schema._traits.get(traitName);
-      if (macroCondition(getGlobalConfig().WarpDrive.features.ENFORCE_STRICT_RESOURCE_FINALIZATION)) {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`The trait ${traitName} used by the trait ${trait.name} MUST be supplied before the resource ${type} can be finalized for use.`);
-          }
-        })(subtrait) : {};
-      } else {
-        warn(`The trait ${traitName} used by the trait ${trait.name} MUST be supplied before the resource ${type} can be finalized for use.`, !!subtrait, {
+      {
+        console.warn(`The trait ${traitName} used by the trait ${trait.name} MUST be supplied before the resource ${type} can be finalized for use.`, !!subtrait, {
           id: 'warp-drive:missing-trait-schema-for-resource'
         });
       }
@@ -11279,11 +11215,11 @@ function getPromise(promise) {
  * See also {@link PromiseState}
  */
 function getPromiseState(promise) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+  (test => {
     if (!test) {
       throw new Error(`getPromiseState expects to be called with a promise: called with ${String(promise)}`);
     }
-  })(promise) : {};
+  })(promise);
   const _promise = getPromise(promise);
   let state = PromiseCache.get(_promise);
   if (!state) {
@@ -11305,7 +11241,7 @@ function cloneResponse(response, overrides) {
   return new Response(response.body, Object.assign(props, overrides));
 }
 let IS_MAYBE_MIRAGE = () => false;
-if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+{
   IS_MAYBE_MIRAGE = () => Boolean(typeof window !== 'undefined' && (window.server?.pretender || window.fetch.toString().replace(/\s+/g, '') !== 'function fetch() { [native code] }'.replace(/\s+/g, '')));
 }
 const MUTATION_OPS = new Set(['updateRecord', 'createRecord', 'deleteRecord']);
@@ -11332,11 +11268,11 @@ const Fetch = {
   async request(context) {
     let response;
     try {
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      (test => {
         if (!test) {
           throw new Error('The Fetch handler expects the request to have a URL, none was provided.');
         }
-      })(context.request.url && typeof context.request.url === 'string') : {};
+      })(context.request.url && typeof context.request.url === 'string');
       response = await _fetch(context.request.url, context.request);
     } catch (e) {
       if (e instanceof DOMException && e.name === 'AbortError') {
@@ -11471,6 +11407,97 @@ const Fetch = {
 function isDict(v) {
   return v !== null && typeof v === 'object';
 }
+
+/**
+ * ## Import
+ *
+ * ```js
+ * import { RequestManager } from '@warp-drive/core';
+ * ```
+ *
+ * For complete usage guide see the [RequestManager Documentation](/guides/).
+ *
+ * ## How It Works
+ *
+ * ```ts
+ * interface RequestManager {
+ *   request<T>(req: RequestInfo): Future<T>;
+ * }
+ * ```
+ *
+ * A RequestManager provides a request/response flow in which configured
+ * handlers are successively given the opportunity to handle, modify, or
+ * pass-along a request.
+ *
+ * <img src="/images/handlers-all-labeled.gif" alt="RequestManager Flow Animation" width="100%" />
+ *
+ * For example:
+ *
+ * ::: code-group
+ *
+ * ```ts [Setup.ts]
+ * import { RequestManager, Fetch } from '@warp-drive/core';
+ * import { AutoCompress } from '@warp-drive/utilities/handlers';
+ * import Auth from 'ember-simple-auth/handler';
+ *
+ * // ... create manager
+ * const manager = new RequestManager()
+ *    .use([Auth, new AutoCompress(), Fetch]); // [!code focus]
+ * ```
+ *
+ * ```ts [Usage.ts]
+ * import Config from './config';
+ *
+ * const { apiUrl } = Config;
+ *
+ * // ... execute a request
+ * const response = await manager.request({
+ *   url: `${apiUrl}/users`
+ * });
+ * ```
+ *
+ * :::
+ *
+ * ### Futures
+ *
+ * The return value of `manager.request` is a `Future`, which allows
+ * access to limited information about the request while it is still
+ * pending and fulfills with the final state when the request completes.
+ *
+ * A `Future` is cancellable via `abort`.
+ *
+ * Handlers may optionally expose a `ReadableStream` to the `Future` for
+ * streaming data; however, when doing so the future should not resolve
+ * until the response stream is fully read.
+ *
+ * ```ts
+ * interface Future<T> extends Promise<StructuredDocument<T>> {
+ *   abort(): void;
+ *
+ *   async getStream(): ReadableStream | null;
+ * }
+ * ```
+ *
+ * ### StructuredDocuments
+ *
+ * A Future resolves with a `StructuredDataDocument` or rejects with a `StructuredErrorDocument`.
+ *
+ * ```ts
+ * interface StructuredDataDocument<T> {
+ *   request: ImmutableRequestInfo;
+ *   response: ImmutableResponseInfo;
+ *   content: T;
+ * }
+ * interface StructuredErrorDocument extends Error {
+ *   request: ImmutableRequestInfo;
+ *   response: ImmutableResponseInfo;
+ *   error: string | object;
+ * }
+ * type StructuredDocument<T> = StructuredDataDocument<T> | StructuredErrorDocument;
+ * ```
+ *
+ * @public
+ */
 class RequestManager {
   /** @internal */
 
@@ -11504,7 +11531,7 @@ class RequestManager {
    * @public
    */
   useCache(cacheHandler) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       if (this._hasCacheHandler) {
         throw new Error(`\`RequestManager.useCache(<handler>)\` May only be invoked once.`);
       }
@@ -11529,7 +11556,7 @@ class RequestManager {
    */
   use(newHandlers) {
     const handlers = this._handlers;
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       if (Object.isFrozen(handlers)) {
         throw new Error(`Cannot add a Handler to a RequestManager after a request has been made`);
       }
@@ -11555,7 +11582,7 @@ class RequestManager {
    */
   request(request) {
     const handlers = this._handlers;
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+    {
       if (!Object.isFrozen(handlers)) {
         Object.freeze(handlers);
       }
@@ -11581,7 +11608,7 @@ class RequestManager {
     // the cache handler will set the result of the request synchronously
     // if it is able to fulfill the request from the cache
     const cacheResult = getRequestResult(requestId);
-    if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
+    {
       if (!request.disableTestWaiter) {
         const newPromise = waitFor(promise);
         const finalPromise = upgradePromise(newPromise.then(result => {
@@ -11660,11 +11687,13 @@ class RequestManager {
  * @mergeModuleWith <project>
  */
 
-// @ts-expect-error adding to globalThis
-globalThis.setWarpDriveLogging = setLogging;
+{
+  // @ts-expect-error adding to globalThis
+  globalThis.setWarpDriveLogging = setLogging;
 
-// @ts-expect-error adding to globalThis
-globalThis.getWarpDriveRuntimeConfig = getRuntimeConfig;
+  // @ts-expect-error adding to globalThis
+  globalThis.getWarpDriveRuntimeConfig = getRuntimeConfig;
+}
 
 /**
  * Options for setting up a Store instance with `useRecommendedStore`.