@warp-drive/core 5.7.0-alpha.10 → 5.7.0-alpha.12

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

@@ -1,12 +1,14 @@
-import { withBrand, EnableHydration, SkipCache } from './types/request.js';
-import { deprecate, warn } from '@ember/debug';
+import { withBrand, EnableHydration, STRUCTURED, SkipCache } from './types/request.js';
 import { macroCondition, getGlobalConfig, dependencySatisfies, importSync } from '@embroider/macros';
+import { deprecate, warn } from '@ember/debug';
 import { setLogging, getRuntimeConfig } from './types/runtime.js';
 import { getOrSetGlobal, peekTransient, setTransient } from './types/-private.js';
 import { CACHE_OWNER, DEBUG_STALE_CACHE_OWNER, DEBUG_IDENTIFIER_BUCKET, DEBUG_CLIENT_ORIGINATED } from './types/identifier.js';
 import { dasherize } from './utils/string.js';
-import { a as createSignal, b as consumeSignal, n as notifySignal, c as createMemo, d as willSyncFlushWatchers, A as ARRAY_SIGNAL } from "./configure-B48bFHOl.js";
+import { a as createSignal, b as consumeSignal, n as notifySignal, c as createMemo, A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, d as willSyncFlushWatchers } from "./configure-B48bFHOl.js";
 import { g as getPromiseResult, s as setPromiseResult } from "./context-COmAnXUQ.js";
+import { RecordStore } from './types/symbols.js';
+import { S as SOURCE$1, C as Context, D as Destroy, a as Checkout } from "./symbols-BoONANuz.js";
 function coerceId(id) {
   if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_NON_STRICT_ID)) {
     let normalized;
@@ -1482,115 +1484,2166 @@ defineGate(ReactiveDocument.prototype, 'meta', {
     return data.meta;
   }
 });
-const TEXT_COLORS = {
-  TEXT: 'inherit',
-  notify: ['white', 'white', 'inherit', 'magenta', 'inherit'],
-  'reactive-ui': ['white', 'white', 'inherit', 'magenta', 'inherit'],
-  graph: ['white', 'white', 'inherit', 'magenta', 'inherit'],
-  request: ['white', 'white', 'inherit', 'magenta', 'inherit'],
-  cache: ['white', 'white', 'inherit', 'magenta', 'inherit']
-};
-const BG_COLORS = {
-  TEXT: 'transparent',
-  notify: ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent'],
-  'reactive-ui': ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent'],
-  graph: ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent'],
-  request: ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent'],
-  cache: ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent']
-};
-const NOTIFY_BORDER = {
-  TEXT: 0,
-  notify: [3, 2, 0, 0, 0],
-  'reactive-ui': [3, 2, 0, 0, 0],
-  graph: [3, 2, 0, 0, 0],
-  request: [3, 2, 0, 0, 0],
-  cache: [3, 2, 0, 0, 0]
-};
-const LIGHT_DARK_ALT = {
-  lightgreen: 'green',
-  green: 'lightgreen'
-};
-function badge(isLight, color, bgColor, border) {
-  return [`color: ${correctColor(isLight, color)}; background-color: ${correctColor(isLight, bgColor)}; padding: ${border}px ${2 * border}px; border-radius: ${border}px;`, `color: ${TEXT_COLORS.TEXT}; background-color: ${BG_COLORS.TEXT};`];
-}
-function colorForBucket(isLight, scope, bucket) {
-  if (scope === 'notify') {
-    return bucket === 'added' ? badge(isLight, 'lightgreen', 'transparent', 0) : bucket === 'removed' ? badge(isLight, 'red', 'transparent', 0) : badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]);
-  }
-  if (scope === 'reactive-ui') {
-    return bucket === 'created' ? badge(isLight, 'lightgreen', 'transparent', 0) : bucket === 'disconnected' ? badge(isLight, 'red', 'transparent', 0) : badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]);
-  }
-  if (scope === 'cache') {
-    return bucket === 'inserted' ? badge(isLight, 'lightgreen', 'transparent', 0) : bucket === 'removed' ? badge(isLight, 'red', 'transparent', 0) : badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]);
-  }
-  return badge(isLight, TEXT_COLORS[scope][3], BG_COLORS[scope][3], NOTIFY_BORDER[scope][3]);
+function getAliasField(context) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    {
+      throw new Error(`Alias field access is not implemented`);
+    }
+  })() : {};
 }
-function logGroup(scope, prefix, subScop1, subScop2, subScop3, subScop4) {
-  // eslint-disable-next-line no-console
-  console.groupCollapsed(..._log(scope, prefix, subScop1, subScop2, subScop3, subScop4));
+function setAliasField(context) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    {
+      throw new Error(`Alias field setting is not implemented`);
+    }
+  })() : {};
+  return false;
 }
-function log(scope, prefix, subScop1, subScop2, subScop3, subScop4) {
-  // eslint-disable-next-line no-console
-  console.log(..._log(scope, prefix, subScop1, subScop2, subScop3, subScop4));
+function isExtensionProp(extensions, prop) {
+  return Boolean(extensions && typeof prop !== 'number' && extensions.has(prop));
 }
-function correctColor(isLight, color) {
-  if (!isLight) {
-    return color;
+function performObjectExtensionGet(receiver, extensions, signals, prop) {
+  const desc = extensions.get(prop);
+  switch (desc.kind) {
+    case 'method':
+      {
+        return desc.fn;
+      }
+    case 'readonly-value':
+      {
+        return desc.value;
+      }
+    case 'mutable-value':
+      {
+        const signal = getOrCreateInternalSignal(signals, receiver, prop, desc.value);
+        // we don't consume this signal, since its not a true local.
+        return signal.value;
+      }
+    case 'readonly-field':
+    case 'mutable-field':
+      {
+        return desc.get.call(receiver);
+      }
+    case 'writeonly-field':
+      {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Cannot get extended field ${String(prop)} as its definition has only a setter`);
+          }
+        })() : {};
+        return undefined;
+      }
+    default:
+      {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Unhandled extension kind ${desc.kind}`);
+          }
+        })() : {};
+        return undefined;
+      }
   }
-  return color in LIGHT_DARK_ALT ? LIGHT_DARK_ALT[color] : color;
 }
-function isLightMode() {
-  if (window?.matchMedia?.('(prefers-color-scheme: light)').matches) {
-    return true;
+function performExtensionSet(receiver, extensions, signals, prop, value) {
+  const desc = extensions.get(prop);
+  switch (desc.kind) {
+    case 'method':
+    case 'readonly-value':
+    case 'readonly-field':
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        {
+          throw new Error(`Cannot set extension field ${String(prop)} as it is a ${desc.kind}`);
+        }
+      })() : {};
+      return false;
+    case 'mutable-value':
+      {
+        const signal = getOrCreateInternalSignal(signals, receiver, prop, desc.value);
+        if (signal.value !== value) {
+          // we don't notify this signal, since its not a true local.
+          signal.value = value;
+        }
+        return true;
+      }
+    case 'writeonly-field':
+    case 'mutable-field':
+      {
+        desc.set.call(receiver, value);
+        return true;
+      }
+    default:
+      {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Unhandled extension kind ${desc.kind}`);
+          }
+        })() : {};
+        return false;
+      }
   }
-  return false;
 }
-function _log(scope, prefix, subScop1, subScop2, subScop3, subScop4) {
-  const isLight = isLightMode();
-  switch (scope) {
-    case 'reactive-ui':
-    case 'notify':
+function performArrayExtensionGet(receiver, extensions, signals, prop, _SIGNAL, boundFns, transaction) {
+  const desc = extensions.get(prop);
+  switch (desc.kind) {
+    case 'method':
       {
-        const scopePath = prefix ? `[${prefix}] ${scope}` : scope;
-        const path = subScop4 ? `${subScop3}.${subScop4}` : subScop3;
-        return [`%c@warp%c-%cdrive%c %c${scopePath}%c %c${subScop1}%c %c${subScop2}%c %c${path}%c`, ...badge(isLight, 'lightgreen', 'transparent', 0), ...badge(isLight, 'magenta', 'transparent', 0), ...badge(isLight, TEXT_COLORS[scope][0], BG_COLORS[scope][0], NOTIFY_BORDER[scope][0]), ...badge(isLight, TEXT_COLORS[scope][1], BG_COLORS[scope][1], NOTIFY_BORDER[scope][1]), ...badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]), ...colorForBucket(isLight, scope, path)];
+        let fn = boundFns.get(prop);
+        if (fn === undefined) {
+          fn = function () {
+            consumeInternalSignal(_SIGNAL);
+            transaction(true);
+            const result = Reflect.apply(desc.fn, receiver, arguments);
+            transaction(false);
+            return result;
+          };
+          boundFns.set(prop, fn);
+        }
+        return fn;
       }
-    case 'cache':
+    case 'mutable-field':
+    case 'readonly-field':
       {
-        const scopePath = prefix ? `${scope} (${prefix})` : scope;
-        return [`%c@warp%c-%cdrive%c %c${scopePath}%c %c${subScop1}%c %c${subScop2}%c %c${subScop3}%c %c${subScop4}%c`, ...badge(isLight, 'lightgreen', 'transparent', 0), ...badge(isLight, 'magenta', 'transparent', 0), ...badge(isLight, TEXT_COLORS[scope][0], BG_COLORS[scope][0], NOTIFY_BORDER[scope][0]), ...badge(isLight, TEXT_COLORS[scope][1], BG_COLORS[scope][1], NOTIFY_BORDER[scope][1]), ...badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]), ...colorForBucket(isLight, scope, subScop3), ...badge(isLight, TEXT_COLORS[scope][4], BG_COLORS[scope][4], NOTIFY_BORDER[scope][4])];
+        return desc.get.call(receiver);
+      }
+    case 'readonly-value':
+      {
+        return desc.value;
+      }
+    case 'mutable-value':
+      {
+        const signal = getOrCreateInternalSignal(signals, receiver, prop, desc.value);
+        // we don't consume this signal, since its not a true local.
+        return signal.value;
+      }
+    case 'writeonly-field':
+      {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Cannot get extended field ${String(prop)} as its definition has only a setter`);
+          }
+        })() : {};
+        return undefined;
+      }
+    default:
+      {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Unhandled extension kind ${desc.kind}`);
+          }
+        })() : {};
+        return undefined;
       }
   }
-  return [];
 }
-class CacheCapabilitiesManager {
-  constructor(_store) {
-    this._store = _store;
-    this._willNotify = false;
-    this._pendingNotifies = new Map();
-  }
-  get identifierCache() {
-    return this._store.identifierCache;
+const ARRAY_GETTER_METHODS$1 = new Set([Symbol.iterator, 'concat', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'flat', 'flatMap', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'map', 'reduce', 'reduceRight', 'slice', 'some', 'values']);
+// const ARRAY_SETTER_METHODS = new Set<KeyType>(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
+const SYNC_PROPS$1 = new Set(['[]', 'length']);
+function isArrayGetter$1(prop) {
+  return ARRAY_GETTER_METHODS$1.has(prop);
+}
+const ARRAY_SETTER_METHODS$1 = new Set(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
+function isArraySetter$1(prop) {
+  return ARRAY_SETTER_METHODS$1.has(prop);
+}
+
+// function isSelfProp<T extends object>(self: T, prop: KeyType): prop is keyof T {
+//   return prop in self;
+// }
+
+function convertToInt$1(prop) {
+  if (typeof prop === 'symbol') return null;
+  const num = Number(prop);
+  if (isNaN(num)) return null;
+  return num % 1 === 0 ? num : null;
+}
+function safeForEach$1(instance, arr, store, callback, target) {
+  if (target === undefined) {
+    target = null;
   }
-  _scheduleNotification(identifier, key) {
-    let pending = this._pendingNotifies.get(identifier);
-    if (!pending) {
-      pending = new Set();
-      this._pendingNotifies.set(identifier, pending);
-    }
-    pending.add(key);
-    if (this._willNotify === true) {
-      return;
-    }
-    this._willNotify = true;
-    // it's possible a cache adhoc notifies us,
-    // in which case we sync flush
-    if (this._store._cbs) {
-      this._store._schedule('notify', () => this._flushNotifications());
-    } else {
-      // TODO @runspired determine if relationship mutations should schedule
-      // into join/run vs immediate flush
-      this._flushNotifications();
+  // clone to prevent mutation
+  arr = arr.slice();
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error('`forEach` expects a function as first argument.');
+    }
+  })(typeof callback === 'function') : {};
+
+  // because we retrieveLatest above we need not worry if array is mutated during iteration
+  // by unloadRecord/rollbackAttributes
+  // push/add/removeObject may still be problematic
+  // but this is a more traditionally expected forEach bug.
+  const length = arr.length; // we need to access length to ensure we are consumed
+
+  for (let index = 0; index < length; index++) {
+    callback.call(target, arr[index], index, instance);
+  }
+  return instance;
+}
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+class ManagedArray {
+  constructor(context, owner, data) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    this[SOURCE$1] = data?.slice();
+    const IS_EDITABLE = context.editable ?? false;
+    this[Context] = context;
+    const schema = context.store.schema;
+    const cache = context.store.cache;
+    const {
+      field
+    } = context;
+    const signals = withSignalStore(this);
+    let _SIGNAL = null;
+    const boundFns = new Map();
+    this.identifier = context.resourceKey;
+    this.path = context.path;
+    this.owner = owner;
+    let transaction = false;
+    const KeyMode = field.options?.key ?? '@identity';
+    // listener.
+    const RefStorage = KeyMode === '@identity' ? WeakMap :
+    // CAUTION CAUTION CAUTION
+    // this is a pile of lies
+    // the Map is Map<string, WeakRef<ReactiveResource>>
+    // but TS does not understand how to juggle modes like this
+    // internal to a method like ours without us duplicating the code
+    // into two separate methods.
+    Map;
+    const ManagedRecordRefs = field.kind === 'schema-array' ? new RefStorage() : null;
+    const extensions = context.legacy ? schema.CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field) : null;
+    const proxy = new Proxy(this[SOURCE$1], {
+      get(target, prop, receiver) {
+        if (prop === ARRAY_SIGNAL) {
+          return _SIGNAL;
+        }
+        if (prop === 'identifier') {
+          return self.identifier;
+        }
+        if (prop === 'owner') {
+          return self.owner;
+        }
+        const index = convertToInt$1(prop);
+        if (_SIGNAL.isStale && (index !== null || SYNC_PROPS$1.has(prop) || isArrayGetter$1(prop))) {
+          _SIGNAL.isStale = false;
+          const newData = cache.getAttr(context.resourceKey, context.path);
+          if (newData && newData !== self[SOURCE$1]) {
+            self[SOURCE$1].length = 0;
+            self[SOURCE$1].push(...newData);
+          }
+        }
+        if (prop === 'length') {
+          return consumeInternalSignal(_SIGNAL), target.length;
+        }
+        if (prop === '[]') return consumeInternalSignal(_SIGNAL), receiver;
+        if (index !== null) {
+          if (!transaction) {
+            consumeInternalSignal(_SIGNAL);
+          }
+          const rawValue = target[index];
+          if (field.kind === 'array') {
+            if (field.type) {
+              const transform = schema.transformation(field);
+              return transform.hydrate(rawValue, field.options ?? null, self.owner);
+            }
+            return rawValue;
+          }
+
+          /**
+           * When the array is polymorphic, we need to determine the real type
+           * in order to apply the correct identity as schema-object identity
+           * is only required to be unique by type
+           */
+          let objectType;
+          if (field.options?.polymorphic) {
+            const typePath = field.options.type ?? 'type';
+            // if we are polymorphic, then context.field.options.type will
+            // either specify a path on the rawValue to use as the type, defaulting to "type" or
+            // 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 => {
+                if (!test) {
+                  throw new Error(`Expected the field to define a hashFn as its type`);
+                }
+              })(field.type) : {};
+              const hashFn = schema.hashFn({
+                type: field.type
+              });
+              // TODO consider if there are better options and name args we could provide.
+              objectType = hashFn(rawValue, null, null);
+            } else {
+              objectType = rawValue[typePath];
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (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') : {};
+            }
+          } else {
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              if (!test) {
+                throw new Error(`A non-polymorphic SchemaArrayField must provide a SchemaObject type in its definition`);
+              }
+            })(field.type) : {};
+            objectType = field.type;
+          }
+
+          /**
+           * When KeyMode=@hash the ReactiveResource is keyed into
+           * ManagedRecordRefs by the return value of @hash on the rawValue.
+           *
+           * This means that we could find a way to only recompute the identity
+           * when ARRAY_SIGNAL is dirty if hash performance becomes a bottleneck.
+           */
+          let schemaObjectKeyValue;
+          if (KeyMode === '@hash') {
+            const hashField = schema.resource({
+              type: objectType
+            }).identity;
+            const hashFn = schema.hashFn(hashField);
+            schemaObjectKeyValue = hashFn(rawValue, hashField.options ?? null, hashField.name);
+          } else {
+            // if mode is not @identity or @index, then access the key path.
+            // we should assert that `mode` is a string
+            // it should read directly from the cache value for that field (e.g. no derivation, no transformation)
+            // 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 => {
+                  if (!test) {
+                    throw new Error('mode must be a string');
+                  }
+                })(typeof KeyMode === 'string' && KeyMode !== '') : {};
+                const modeField = schema.fields({
+                  type: objectType
+                }).get(KeyMode);
+                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                  if (!test) {
+                    throw new Error('field must exist in schema');
+                  }
+                })(modeField) : {};
+                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                  if (!test) {
+                    throw new Error('field must be a GenericField or LegacyAttributeField');
+                  }
+                })(modeField.kind === 'field' || modeField.kind === 'attribute') : {};
+              }
+            }
+            schemaObjectKeyValue = KeyMode === '@identity' ? rawValue : KeyMode === '@index' ? index : rawValue[KeyMode];
+          }
+          if (!schemaObjectKeyValue) {
+            macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+              {
+                throw new Error(`Unexpected out of bounds access on SchemaArray`);
+              }
+            })() : {};
+            return undefined;
+          }
+          const recordRef = ManagedRecordRefs.get(schemaObjectKeyValue);
+          const record = recordRef?.value.deref();
+
+          // confirm the type and key still match
+          if (record && recordRef.type === objectType && recordRef.identity === schemaObjectKeyValue) {
+            if (recordRef.index !== index) {
+              recordRef.index = index;
+              recordRef.context.path[recordRef.context.path.length - 1] = index;
+            }
+            return record;
+          } else if (record) {
+            // TODO schedule idle once we can
+            void Promise.resolve().then(() => {
+              record[Destroy]();
+            });
+          }
+          const recordPath = context.path.slice();
+          // this is a dirty lie since path is string[] but really we
+          // should change the types for paths to `Array<string | number>`
+          recordPath.push(index);
+          const objectContext = {
+            store: context.store,
+            resourceKey: context.resourceKey,
+            modeName: context.modeName,
+            legacy: context.legacy,
+            editable: context.editable,
+            path: recordPath,
+            field: field,
+            value: objectType
+          };
+          const schemaObject = new ReactiveResource(objectContext);
+          ManagedRecordRefs.set(schemaObjectKeyValue, {
+            type: objectType,
+            identity: schemaObjectKeyValue,
+            index,
+            context: objectContext,
+            value: new WeakRef(schemaObject)
+          });
+          return schemaObject;
+        }
+        if (isArrayGetter$1(prop)) {
+          let fn = boundFns.get(prop);
+          if (fn === undefined) {
+            if (prop === 'forEach') {
+              fn = function () {
+                consumeInternalSignal(_SIGNAL);
+                transaction = true;
+                const result = safeForEach$1(receiver, target, context.store, arguments[0], arguments[1]);
+                transaction = false;
+                return result;
+              };
+            } else {
+              fn = function () {
+                consumeInternalSignal(_SIGNAL);
+                // array functions must run through Reflect to work properly
+                // binding via other means will not work.
+                transaction = true;
+                const result = Reflect.apply(target[prop], receiver, arguments);
+                transaction = false;
+                return result;
+              };
+            }
+            boundFns.set(prop, fn);
+          }
+          return fn;
+        }
+        if (isArraySetter$1(prop)) {
+          let fn = boundFns.get(prop);
+          if (fn === undefined) {
+            fn = function () {
+              if (!IS_EDITABLE) {
+                throw new Error(`Mutating this array via ${String(prop)} is not allowed because the record is not editable`);
+              }
+              consumeInternalSignal(_SIGNAL);
+              transaction = true;
+              const result = Reflect.apply(target[prop], receiver, arguments);
+              transaction = false;
+              return result;
+            };
+            boundFns.set(prop, fn);
+          }
+          return fn;
+        }
+        if (isExtensionProp(extensions, prop)) {
+          return performArrayExtensionGet(receiver, extensions, signals, prop, _SIGNAL, boundFns, v => void (transaction = v));
+        }
+        return Reflect.get(target, prop, receiver);
+      },
+      set(target, prop, value, receiver) {
+        if (!IS_EDITABLE) {
+          let errorPath = context.resourceKey.type;
+          if (context.path) {
+            errorPath = context.path[context.path.length - 1];
+          }
+          throw new Error(`Cannot set ${String(prop)} on ${errorPath} because the record is not editable`);
+        }
+        if (prop === 'identifier') {
+          self.identifier = value;
+          return true;
+        }
+        if (prop === 'owner') {
+          self.owner = value;
+          return true;
+        }
+        if (isExtensionProp(extensions, prop)) {
+          return performExtensionSet(receiver, extensions, signals, prop, value);
+        }
+        const reflect = Reflect.set(target, prop, value, receiver);
+        if (reflect) {
+          if (!field.type) {
+            cache.setAttr(context.resourceKey, context.path, self[SOURCE$1]);
+            _SIGNAL.isStale = true;
+            return true;
+          }
+          let rawValue = self[SOURCE$1];
+          if (field.kind !== 'schema-array') {
+            const transform = schema.transformation(field);
+            if (!transform) {
+              throw new Error(`No '${field.type}' transform defined for use by ${context.resourceKey.type}.${String(prop)}`);
+            }
+            rawValue = self[SOURCE$1].map(item => transform.serialize(item, field.options ?? null, self.owner));
+          }
+          cache.setAttr(context.resourceKey, context.path, rawValue);
+          _SIGNAL.isStale = true;
+        }
+        return reflect;
+      },
+      has(target, prop) {
+        if (prop === 'identifier' || prop === 'owner' || prop === ARRAY_SIGNAL) {
+          return true;
+        }
+        return Reflect.has(target, prop);
+      }
+    });
+
+    // we entangle the signal on the returned proxy since that is
+    // the object that other code will be interfacing with.
+    _SIGNAL = entangleSignal(signals, proxy, ARRAY_SIGNAL, undefined);
+    return proxy;
+  }
+}
+
+// this will error if someone tries to call
+// A(identifierArray) since it is not configurable
+// which is preferable to the `meta` override we used
+// before which required importing all of Ember
+const desc$1 = {
+  enumerable: true,
+  configurable: false,
+  get: function () {
+    // here to support computed chains
+    // and {{#each}}
+    if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_COMPUTED_CHAINS)) {
+      return this;
+    }
+  }
+};
+// compat(desc);
+Object.defineProperty(ManagedArray.prototype, '[]', desc$1);
+function getArrayField(context) {
+  const signal = entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  // the thing we hand out needs to know its owner and path in a private manner
+  // its "address" is the parent identifier (identifier) + field name (field.name)
+  //  in the nested object case field name here is the full dot path from root resource to this value
+  // its "key" is the field on the parent record
+  // its "owner" is the parent record
+  const {
+    record
+  } = context;
+  let managedArray = signal.value;
+  if (managedArray) {
+    return managedArray;
+  } else {
+    const {
+      store,
+      resourceKey,
+      path,
+      field
+    } = context;
+    const {
+      cache
+    } = store;
+    let rawValue = context.editable ? cache.getAttr(resourceKey, path) : cache.getRemoteAttr(resourceKey, path);
+    if (!rawValue && field.kind === 'schema-array' && field.options?.defaultValue) {
+      rawValue = [];
+    }
+    if (!rawValue) {
+      return null;
+    }
+    managedArray = new ManagedArray(context, record, rawValue);
+    signal.value = managedArray;
+  }
+  return managedArray;
+}
+function setArrayField(context) {
+  const {
+    field,
+    record,
+    value
+  } = context;
+  const {
+    cache,
+    schema
+  } = context.store;
+  const fieldSignal = peekInternalSignal(context.signals, context.path.at(-1));
+  const peeked = fieldSignal?.value;
+  const transform = field.type ? schema.transformation(field) : null;
+  const rawValue = 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 => {
+      if (!test) {
+        throw new Error(`Expected the peekManagedArray for ${field.kind} to return a ManagedArray`);
+      }
+    })(ARRAY_SIGNAL in peeked) : {};
+    const arrSignal = peeked[ARRAY_SIGNAL];
+    arrSignal.isStale = true;
+    // TODO run array destroy?
+  }
+  if (!Array.isArray(rawValue) && fieldSignal) {
+    fieldSignal.value = null;
+  }
+  return true;
+}
+function getAttributeField(context) {
+  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  const {
+    cache
+  } = context.store;
+  return context.editable ? cache.getAttr(context.resourceKey, context.path) : cache.getRemoteAttr(context.resourceKey, context.path);
+}
+function setAttributeField(context) {
+  context.store.cache.setAttr(context.resourceKey, context.path, context.value);
+  return true;
+}
+const InvalidKinds = ['alias', 'derived', '@local'];
+function isInvalidKind(kind) {
+  return InvalidKinds.includes(kind);
+}
+function isNonIdentityCacheableField(field) {
+  return !isInvalidKind(field.kind) && field.kind !== '@id' && field.kind !== '@hash';
+}
+function getFieldCacheKeyStrict(field) {
+  return field.sourceKey || field.name;
+}
+function getFieldCacheKey(field) {
+  return 'sourceKey' in field && field.sourceKey ? field.sourceKey : field.name;
+}
+function getBelongsToField(context) {
+  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  const {
+    field,
+    resourceKey,
+    store
+  } = context;
+  const {
+    schema,
+    cache
+  } = store;
+  if (field.options.linksMode) {
+    const rawValue = context.editable ? cache.getRelationship(resourceKey, getFieldCacheKeyStrict(field)) : cache.getRemoteRelationship(resourceKey, getFieldCacheKeyStrict(field));
+    return rawValue.data ? store.peekRecord(rawValue.data) : null;
+  }
+
+  // FIXME move this to a "LegacyMode" make this part of "PolarisMode"
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Can only use belongsTo fields when the resource is in legacy mode`);
+    }
+  })(context.legacy) : {};
+  return schema._kind('@legacy', 'belongsTo').get(store, context.record, resourceKey, field);
+}
+function setBelongsToField(context) {
+  const {
+    store
+  } = context;
+  const {
+    schema
+  } = store;
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Can only mutate belongsTo fields when the resource is in legacy mode`);
+    }
+  })(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 => {
+    {
+      throw new Error(`Accessing collection fields is not yet implemented`);
+    }
+  })() : {};
+}
+function setCollectionField(context) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    {
+      throw new Error(`Setting collection fields is not yet implemented`);
+    }
+  })() : {};
+  return false;
+}
+function getDerivedField(context) {
+  const {
+    schema
+  } = context.store;
+  return schema.derivation(context.field)(context.record, context.field.options ?? null, context.field.name);
+}
+function setDerivedField(context) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (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) {
+  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  const {
+    cache,
+    schema
+  } = context.store;
+  const rawValue = context.editable ? cache.getAttr(context.resourceKey, context.path) : cache.getRemoteAttr(context.resourceKey, context.path);
+  const {
+    field
+  } = context;
+  if (!field.type) {
+    return rawValue;
+  }
+  const transform = schema.transformation(field);
+  return transform.hydrate(rawValue, field.options ?? null, context.record);
+}
+function setGenericField(context) {
+  const {
+    cache,
+    schema
+  } = context.store;
+  const {
+    field
+  } = context;
+  if (!field.type) {
+    cache.setAttr(context.resourceKey, context.path, context.value);
+    return true;
+  }
+  const transform = schema.transformation(field);
+  const rawValue = transform.serialize(context.value, field.options ?? null, context.record);
+  cache.setAttr(context.resourceKey, context.path, rawValue);
+  return true;
+}
+class ManyArrayManager {
+  constructor(record, editable) {
+    const context = record[Context];
+    this.record = record;
+    this.store = context.store;
+    this.identifier = context.resourceKey;
+    this.editable = editable;
+  }
+  _syncArray(array) {
+    const method = this.editable ? 'getRelationship' : 'getRemoteRelationship';
+    // FIXME field needs to use sourceKey
+    const rawValue = this.store.cache[method](this.identifier, array.key);
+    if (rawValue.meta) {
+      array.meta = rawValue.meta;
+    }
+    if (rawValue.links) {
+      array.links = rawValue.links;
+    }
+    const currentState = array[SOURCE];
+
+    // unlike in the normal RecordArray case, we don't need to divorce the reference
+    // because we don't need to worry about associate/disassociate since the graph
+    // takes care of that for us
+    if (currentState !== rawValue.data) {
+      currentState.length = 0;
+      fastPush(currentState, rawValue.data);
+    }
+  }
+  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 => {
+      if (!test) {
+        throw new Error(`Expected a hasMany field for ${key}`);
+      }
+    })(field?.kind === 'hasMany') : {};
+    const cacheOptions = options ? extractCacheOptions(options) : {
+      reload: true
+    };
+    cacheOptions.types = [field.type];
+    const rawValue = this.store.cache.getRelationship(this.identifier, key);
+    const req = {
+      url: getRelatedLink(rawValue),
+      op: 'findHasMany',
+      method: 'GET',
+      records: rawValue.data,
+      cacheOptions,
+      options: {
+        field,
+        identifier: this.identifier,
+        links: rawValue.links,
+        meta: rawValue.meta
+      },
+      [EnableHydration]: false
+    };
+    return this.store.request(req);
+  }
+  mutate(mutation) {
+    this.store.cache.mutate(mutation);
+  }
+}
+function getRelatedLink(resource) {
+  const related = resource.links?.related;
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected a related link`);
+    }
+  })(related) : {};
+  return typeof related === 'object' ? related.href : related;
+}
+function extractCacheOptions(options) {
+  const cacheOptions = {};
+  if ('reload' in options) {
+    cacheOptions.reload = options.reload;
+  }
+  if ('backgroundReload' in options) {
+    cacheOptions.backgroundReload = options.backgroundReload;
+  }
+  return cacheOptions;
+}
+function getHasManyField(context) {
+  const signal = entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  const {
+    store,
+    field
+  } = context;
+  if (field.options.linksMode) {
+    const {
+      record
+    } = context;
+    // the thing we hand out needs to know its owner and path in a private manner
+    // its "address" is the parent identifier (identifier) + field name (field.name)
+    //  in the nested object case field name here is the full dot path from root resource to this value
+    // its "key" is the field on the parent record
+    // its "owner" is the parent record
+
+    const cached = signal.value;
+    if (cached) {
+      return cached;
+    }
+    const {
+      editable,
+      resourceKey
+    } = context;
+    const {
+      cache
+    } = store;
+    const rawValue = cache.getRelationship(resourceKey, getFieldCacheKeyStrict(field));
+    if (!rawValue) {
+      return null;
+    }
+    const managedArray = new RelatedCollection({
+      store,
+      type: field.type,
+      identifier: resourceKey,
+      cache,
+      field: context.legacy ? field : undefined,
+      // we divorce the reference here because ManyArray mutates the target directly
+      // before sending the mutation op to the cache. We may be able to avoid this in the future
+      identifiers: rawValue.data?.slice(),
+      key: field.name,
+      meta: rawValue.meta || null,
+      links: rawValue.links || null,
+      isPolymorphic: field.options.polymorphic ?? false,
+      isAsync: field.options.async ?? false,
+      // TODO: Grab the proper value
+      _inverseIsAsync: false,
+      // @ts-expect-error Typescript doesn't have a way for us to thread the generic backwards so it infers unknown instead of T
+      manager: new ManyArrayManager(record, editable),
+      isLoaded: true,
+      allowMutation: editable
+    });
+    signal.value = managedArray;
+    return managedArray;
+  }
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
+    }
+  })(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 => {
+    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 => {
+    if (!test) {
+      throw new Error(`You must pass an array of records to set a hasMany relationship`);
+    }
+  })(Array.isArray(context.value)) : {};
+  store.schema._kind('@legacy', 'hasMany').set(store, context.record, context.resourceKey, context.field, context.value);
+  return true;
+}
+function getHashField(context) {
+  const {
+    field,
+    path,
+    resourceKey
+  } = context;
+  const {
+    schema,
+    cache
+  } = context.store;
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Cannot use a ${field.kind} directly on a resource.`);
+    }
+  })(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 => {
+    {
+      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) {
+  entangleSignal(context.signals, context.record, '@identity', null);
+  return context.resourceKey.id;
+}
+function setIdentityField(context) {
+  const {
+    value,
+    resourceKey,
+    store
+  } = context;
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected to receive a string id`);
+    }
+  })(typeof value === 'string' && value.length) : {};
+  const normalizedId = String(value);
+  const didChange = normalizedId !== resourceKey.id;
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (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) : {};
+  if (normalizedId !== null && didChange) {
+    store._instanceCache.setRecordId(resourceKey, normalizedId);
+    store.notifications.notify(resourceKey, 'identity');
+  }
+  return true;
+}
+function getLocalField(context) {
+  const {
+    field
+  } = context;
+  const signal = getOrCreateInternalSignal(context.signals, context.record, field.name, field.options?.defaultValue ?? null);
+  consumeInternalSignal(signal);
+  return signal.value;
+}
+function setLocalField(context) {
+  const {
+    value
+  } = context;
+  const signal = getOrCreateInternalSignal(context.signals, context.record, context.field.name, value);
+  if (signal.value !== value) {
+    signal.value = value;
+    notifyInternalSignal(signal);
+  }
+  return true;
+}
+const ObjectSymbols = new Set([OBJECT_SIGNAL, Context, SOURCE$1]);
+
+// const ignoredGlobalFields = new Set<string>(['setInterval', 'nodeType', 'nodeName', 'length', 'document', STRUCTURED]);
+
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+class ManagedObject {
+  constructor(context) {
+    const {
+      field,
+      path
+    } = context;
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    this[SOURCE$1] = Object.assign({}, context.value);
+    const signals = withSignalStore(this);
+    const _SIGNAL = this[OBJECT_SIGNAL] = entangleSignal(signals, this, OBJECT_SIGNAL, undefined);
+    this[Context] = context;
+    const identifier = context.resourceKey;
+    const {
+      cache,
+      schema
+    } = context.store;
+
+    // prettier-ignore
+    const extensions = !context.legacy ? null : schema.CAUTION_MEGA_DANGER_ZONE_objectExtensions(field, null);
+    const proxy = new Proxy(this[SOURCE$1], {
+      ownKeys() {
+        return Object.keys(self[SOURCE$1]);
+      },
+      has(target, prop) {
+        return prop in self[SOURCE$1];
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        return {
+          writable: context.editable,
+          enumerable: true,
+          configurable: true
+        };
+      },
+      get(target, prop, receiver) {
+        if (ObjectSymbols.has(prop)) {
+          return self[prop];
+        }
+        if (prop === Symbol.toPrimitive) {
+          return () => null;
+        }
+        if (prop === Symbol.toStringTag) {
+          return `ManagedObject<${identifier.type}:${identifier.id} (${identifier.lid})>`;
+        }
+        if (prop === 'constructor') {
+          return Object;
+        }
+        if (prop === 'toString') {
+          return function () {
+            return `ManagedObject<${identifier.type}:${identifier.id} (${identifier.lid})>`;
+          };
+        }
+        if (prop === 'toHTML') {
+          return function () {
+            return '<span>ManagedObject</span>';
+          };
+        }
+        if (_SIGNAL.isStale) {
+          _SIGNAL.isStale = false;
+          let newData = cache.getAttr(identifier, path);
+          if (newData && newData !== self[SOURCE$1]) {
+            if (field.type) {
+              const transform = schema.transformation(field);
+              newData = transform.hydrate(newData, field.options ?? null, context.record);
+            }
+            self[SOURCE$1] = Object.assign({}, newData); // Add type assertion for newData
+          }
+        }
+
+        // toJSON and extensions need to come after we update data if stale
+        if (prop === 'toJSON') {
+          return function () {
+            return structuredClone(self[SOURCE$1]);
+          };
+        }
+
+        // we always defer to data before extensions
+        if (prop in self[SOURCE$1]) {
+          consumeInternalSignal(_SIGNAL);
+          return self[SOURCE$1][prop];
+        }
+        if (isExtensionProp(extensions, prop)) {
+          return performObjectExtensionGet(receiver, extensions, signals, prop);
+        }
+        return Reflect.get(target, prop, receiver);
+      },
+      set(target, prop, value, receiver) {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`Cannot set read-only property '${String(prop)}' on ManagedObject`);
+          }
+        })(context.editable) : {};
+
+        // since objects function as dictionaries, we can't defer to schema/data before extensions
+        // unless the prop is in the existing data.
+        if (!(prop in self[SOURCE$1]) && isExtensionProp(extensions, prop)) {
+          return performExtensionSet(receiver, extensions, signals, prop, value);
+        }
+        const reflect = Reflect.set(target, prop, value, receiver);
+        if (!reflect) {
+          return false;
+        }
+        if (!field.type) {
+          cache.setAttr(identifier, path, self[SOURCE$1]);
+        } else {
+          const transform = schema.transformation(field);
+          const val = transform.serialize(self[SOURCE$1], field.options ?? null, context.record);
+          cache.setAttr(identifier, path, val);
+        }
+        _SIGNAL.isStale = true;
+        return true;
+      }
+    });
+    return proxy;
+  }
+}
+const ManagedObjectMap = getOrSetGlobal('ManagedObjectMap', new Map());
+function peekManagedObject(record, field) {
+  const managedObjectMapForRecord = ManagedObjectMap.get(record);
+  if (managedObjectMapForRecord) {
+    return managedObjectMapForRecord.get(field.name);
+  }
+}
+function getObjectField(context) {
+  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  const {
+    record,
+    field
+  } = context;
+  const managedObjectMapForRecord = ManagedObjectMap.get(record);
+  let managedObject;
+  if (managedObjectMapForRecord) {
+    managedObject = managedObjectMapForRecord.get(field.name);
+  }
+  if (managedObject) {
+    return managedObject;
+  } else {
+    const {
+      store,
+      resourceKey,
+      path
+    } = context;
+    const {
+      cache,
+      schema
+    } = store;
+    let rawValue = context.editable ? cache.getAttr(resourceKey, path) : cache.getRemoteAttr(resourceKey, path);
+    if (!rawValue) {
+      return null;
+    }
+    if (field.type) {
+      const transform = schema.transformation(field);
+      rawValue = transform.hydrate(rawValue, field.options ?? null, record);
+    }
+    managedObject = new ManagedObject({
+      store,
+      resourceKey,
+      modeName: context.modeName,
+      legacy: context.legacy,
+      editable: context.editable,
+      path,
+      field,
+      record,
+      signals: context.signals,
+      value: rawValue
+    });
+    if (!managedObjectMapForRecord) {
+      ManagedObjectMap.set(record, new Map([[field.name, managedObject]]));
+    } else {
+      managedObjectMapForRecord.set(field.name, managedObject);
+    }
+  }
+  return managedObject;
+}
+function setObjectField(context) {
+  const {
+    field,
+    value,
+    record
+  } = context;
+  const {
+    cache,
+    schema
+  } = context.store;
+  if (!field.type) {
+    let newValue = value;
+    if (value !== null) {
+      newValue = {
+        ...value
+      };
+    } else {
+      ManagedObjectMap.delete(record);
+    }
+    cache.setAttr(context.resourceKey, context.path, newValue);
+    const peeked = peekManagedObject(record, field);
+    if (peeked) {
+      const objSignal = peeked[OBJECT_SIGNAL];
+      objSignal.isStale = true;
+    }
+    return true;
+  }
+  const transform = schema.transformation(field);
+  const rawValue = transform.serialize({
+    ...value
+  }, field.options ?? null, record);
+  cache.setAttr(context.resourceKey, context.path, rawValue);
+  const peeked = peekManagedObject(record, field);
+  if (peeked) {
+    const objSignal = peeked[OBJECT_SIGNAL];
+    objSignal.isStale = true;
+  }
+  return true;
+}
+
+// TODO probably this should just be a Document
+// but its separate until we work out the lid situation
+class ResourceRelationship {
+  constructor(context) {
+    const {
+      store,
+      resourceKey
+    } = context;
+    const {
+      cache
+    } = store;
+    const name = getFieldCacheKeyStrict(context.field);
+    const rawValue = context.editable ? cache.getRelationship(resourceKey, name) : cache.getRemoteRelationship(resourceKey, name);
+
+    // TODO setup true lids for relationship documents
+    // @ts-expect-error we need to give relationship documents a lid
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    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;
+  }
+  fetch(options) {
+    const url = options?.url ?? getHref(this.links.related) ?? getHref(this.links.self) ?? null;
+    if (!url) {
+      throw new Error(`Cannot ${options?.method ?? 'fetch'} ${this[Context].resourceKey.type}.${String(this.name)} because it has no related link`);
+    }
+    const request = Object.assign({
+      url,
+      method: 'GET'
+    }, options);
+    return this[Context].store.request(request);
+  }
+}
+defineSignal(ResourceRelationship.prototype, 'data', null);
+defineSignal(ResourceRelationship.prototype, 'links', null);
+defineSignal(ResourceRelationship.prototype, 'meta', null);
+function getHref(link) {
+  if (!link) {
+    return null;
+  }
+  if (typeof link === 'string') {
+    return link;
+  }
+  return link.href;
+}
+function getResourceField(context) {
+  entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  return new ResourceRelationship(context);
+}
+function setResourceField(context) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    {
+      throw new Error(`setting resource relationships is not yet supported`);
+    }
+  })() : {};
+  return false;
+}
+function setSchemaArrayField(context) {
+  const arrayValue = context.value?.slice();
+  const fieldSignal = peekInternalSignal(context.signals, context.path.at(-1));
+  const peeked = fieldSignal?.value;
+  context.store.cache.setAttr(context.resourceKey, context.path, arrayValue);
+  if (peeked) {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected the peekManagedArray for ${context.field.kind} to return a ManagedArray`);
+      }
+    })(ARRAY_SIGNAL in peeked) : {};
+    const arrSignal = peeked[ARRAY_SIGNAL];
+    arrSignal.isStale = true;
+    if (!Array.isArray(arrayValue)) {
+      fieldSignal.value = null;
+    }
+  }
+  return true;
+}
+function getSchemaObjectField(context) {
+  const signal = entangleSignal(context.signals, context.record, context.path.at(-1), null);
+  const {
+    store,
+    resourceKey,
+    path,
+    field
+  } = context;
+  const {
+    cache
+  } = store;
+  let rawValue = context.editable ? cache.getAttr(resourceKey, path) : cache.getRemoteAttr(resourceKey, path);
+  if (!rawValue && !field.options?.polymorphic && field.options?.defaultValue) {
+    rawValue = {};
+  }
+  if (!rawValue) {
+    if (signal.value) {
+      const value = signal.value;
+      // TODO if we had idle scheduling this should be done there.
+      void Promise.resolve().then(() => {
+        value.value[Destroy]();
+      });
+      signal.value = null;
+    }
+    return null;
+  }
+  const {
+    schema
+  } = store;
+  let objectType;
+  if (field.options?.polymorphic) {
+    const typePath = field.options.type ?? 'type';
+    // if we are polymorphic, then context.field.options.type will
+    // either specify a path on the rawValue to use as the type, defaulting to "type" or
+    // 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 => {
+        if (!test) {
+          throw new Error(`Expected the field to define a hashFn as its type`);
+        }
+      })(field.type) : {};
+      const hashFn = schema.hashFn({
+        type: field.type
+      });
+      // TODO consider if there are better options and name args we could provide.
+      objectType = hashFn(rawValue, null, null);
+    } else {
+      objectType = rawValue[typePath];
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (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') : {};
+    }
+  } else {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`A non-polymorphic SchemaObjectField must provide a SchemaObject type in its definition`);
+      }
+    })(field.type) : {};
+    objectType = field.type;
+  }
+  const hashField = schema.resource({
+    type: objectType
+  }).identity;
+  const identity = hashField ? schema.hashFn(hashField)(rawValue, hashField.options ?? null, hashField.name) : field.name;
+  const cachedSchemaObject = signal.value;
+  if (cachedSchemaObject) {
+    if (cachedSchemaObject.type === objectType && cachedSchemaObject.identity === identity) {
+      return cachedSchemaObject.value;
+    } else {
+      // TODO if we had idle scheduling this should be done there.
+      void Promise.resolve().then(() => {
+        cachedSchemaObject.value[Destroy]();
+      });
+    }
+  }
+  const schemaObject = new ReactiveResource({
+    store: context.store,
+    resourceKey: context.resourceKey,
+    modeName: context.modeName,
+    legacy: context.legacy,
+    editable: context.editable,
+    path: context.path,
+    field: context.field,
+    value: objectType
+  });
+  signal.value = {
+    type: objectType,
+    identity: identity,
+    value: schemaObject
+  };
+  return schemaObject;
+}
+function setSchemaObjectField(context) {
+  const {
+    store,
+    value
+  } = context;
+  let newValue = value;
+  if (value !== null) {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected value to be an object`);
+      }
+    })(typeof value === 'object') : {};
+    newValue = {
+      ...value
+    };
+    // FIXME the case of field.type to string here is likely incorrect
+    const schemaFields = store.schema.fields({
+      type: context.field.type
+    });
+    for (const key of Object.keys(newValue)) {
+      if (!schemaFields.has(key)) {
+        throw new Error(`Field ${key} does not exist on schema object ${context.field.type}`);
+      }
+    }
+  } else {
+    ManagedObjectMap.delete(context.record);
+  }
+  store.cache.setAttr(context.resourceKey, context.path, newValue);
+  // const peeked = peekManagedObject(self, field);
+  // if (peeked) {
+  //   const objSignal = peeked[OBJECT_SIGNAL];
+  //   objSignal.isStale = true;
+  // }
+  return true;
+}
+const DefaultMode = {
+  '@hash': {
+    get: getHashField,
+    set: setHashField,
+    mutable: false,
+    enumerable: false,
+    serializable: false
+  },
+  '@id': {
+    get: getIdentityField,
+    set: setIdentityField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  '@local': {
+    get: getLocalField,
+    set: setLocalField,
+    mutable: true,
+    enumerable: false,
+    serializable: false
+  },
+  alias: {
+    get: getAliasField,
+    set: setAliasField,
+    mutable: true,
+    enumerable: true,
+    serializable: false
+  },
+  array: {
+    get: getArrayField,
+    set: setArrayField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  attribute: {
+    get: getAttributeField,
+    set: setAttributeField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  belongsTo: {
+    get: getBelongsToField,
+    set: setBelongsToField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  collection: {
+    get: getCollectionField,
+    set: setCollectionField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  derived: {
+    get: getDerivedField,
+    set: setDerivedField,
+    mutable: true,
+    enumerable: true,
+    serializable: false
+  },
+  field: {
+    get: getGenericField,
+    set: setGenericField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  hasMany: {
+    get: getHasManyField,
+    set: setHasManyField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  object: {
+    get: getObjectField,
+    set: setObjectField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  resource: {
+    get: getResourceField,
+    set: setResourceField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  'schema-array': {
+    get: getArrayField,
+    set: setSchemaArrayField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  },
+  'schema-object': {
+    get: getSchemaObjectField,
+    set: setSchemaObjectField,
+    mutable: true,
+    enumerable: true,
+    serializable: true
+  }
+};
+const IgnoredGlobalFields = new Set(['length', 'nodeType', 'then', 'setInterval', 'document', STRUCTURED]);
+const symbolList = [Context, Destroy, RecordStore, Checkout];
+const RecordSymbols = new Set(symbolList);
+function isPathMatch(a, b) {
+  return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+function isNonEnumerableProp(prop) {
+  return prop === 'constructor' || prop === 'prototype' || prop === '__proto__' || prop === 'toString' || prop === 'toJSON' || prop === 'toHTML' || typeof prop === 'symbol';
+}
+const Editables = new Map();
+/**
+ * A class that uses a the ResourceSchema for a ResourceType
+ * and a ResouceKey to transform data from the cache into a rich, reactive
+ * object.
+ *
+ * This class is not directly instantiable. To use it, you should
+ * configure the store's `instantiateRecord` and `teardownRecord` hooks
+ * with the matching hooks provided by this package.
+ *
+ * @hideconstructor
+ * @public
+ */
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+class ReactiveResource {
+  constructor(context) {
+    const resourceKey = context.resourceKey;
+    const isEmbedded = context.path !== null;
+    const schema = context.store.schema;
+    const objectType = isEmbedded ? context.value : resourceKey.type;
+    const ResourceSchema = schema.resource(isEmbedded ? {
+      type: objectType
+    } : resourceKey);
+    const identityField = ResourceSchema.identity;
+    const BoundFns = new Map();
+
+    // prettier-ignore
+    const extensions = !context.legacy ? null : isEmbedded ? schema.CAUTION_MEGA_DANGER_ZONE_objectExtensions(context.field, objectType) : schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resourceKey);
+    this[Context] = context;
+    this[RecordStore] = context.store;
+    const fields = isEmbedded ? schema.fields({
+      type: objectType
+    }) : schema.fields(resourceKey);
+    const method = typeof schema.cacheFields === 'function' ? 'cacheFields' : 'fields';
+    const cacheFields = isEmbedded ? schema[method]({
+      type: objectType
+    }) : schema[method](resourceKey);
+    const signals = withSignalStore(this);
+    this.___notifications = context.store.notifications.subscribe(resourceKey, (_, type, key) => {
+      switch (type) {
+        case 'identity':
+          {
+            if (isEmbedded || !identityField) return; // base paths never apply to embedded records
+
+            if (identityField.name && identityField.kind === '@id') {
+              const signal = signals.get('@identity');
+              if (signal) {
+                notifyInternalSignal(signal);
+              }
+            }
+            break;
+          }
+        case 'attributes':
+          if (key) {
+            if (Array.isArray(key)) {
+              if (context.path === null) return; // deep paths will be handled by embedded records
+              // TODO we should have the notification manager
+              // ensure it is safe for each callback to mutate this array
+              if (isPathMatch(context.path, key)) {
+                // handle the notification
+                // TODO we should likely handle this notification here
+                // also we should add a LOGGING flag
+                // eslint-disable-next-line no-console
+                console.warn(`Notification unhandled for ${key.join(',')} on ${resourceKey.type}`, proxy);
+                return;
+              }
+
+              // TODO we should add a LOGGING flag
+              // console.log(`Deep notification skipped for ${key.join('.')} on ${identifier.type}`, proxy);
+              // deep notify the key path
+            } else {
+              if (isEmbedded) return; // base paths never apply to embedded records
+
+              // TODO determine what LOGGING flag to wrap this in if any
+              // console.log(`Notification for ${key} on ${identifier.type}`, proxy);
+              const signal = signals.get(key);
+              if (signal) {
+                notifyInternalSignal(signal);
+              }
+              const field = cacheFields.get(key);
+              if (field?.kind === 'array' || field?.kind === 'schema-array') {
+                const peeked = signal?.value;
+                if (peeked) {
+                  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                    if (!test) {
+                      throw new Error(`Expected the peekManagedArray for ${field.kind} to return a ManagedArray`);
+                    }
+                  })(ARRAY_SIGNAL in peeked) : {};
+                  const arrSignal = peeked[ARRAY_SIGNAL];
+                  notifyInternalSignal(arrSignal);
+                }
+              }
+              if (field?.kind === 'object') {
+                const peeked = peekManagedObject(proxy, field);
+                if (peeked) {
+                  const objSignal = peeked[OBJECT_SIGNAL];
+                  notifyInternalSignal(objSignal);
+                }
+              }
+            }
+          }
+          break;
+        case 'relationships':
+          if (key) {
+            if (Array.isArray(key)) ;else {
+              if (isEmbedded) return; // base paths never apply to embedded records
+
+              const field = cacheFields.get(key);
+              macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                if (!test) {
+                  throw new Error(`Expected relationship ${key} to be the name of a 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);
+                const signal = signals.get(key);
+                if (signal) {
+                  notifyInternalSignal(signal);
+                }
+                // FIXME
+              } else if (field.kind === 'resource') ;else if (field.kind === 'hasMany') {
+                if (field.options.linksMode) {
+                  const signal = signals.get(key);
+                  if (signal) {
+                    const peeked = signal.value;
+                    if (peeked) {
+                      notifyInternalSignal(peeked[ARRAY_SIGNAL]);
+                    }
+                  }
+                  return;
+                }
+                macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                  if (!test) {
+                    throw new Error(`Can only use hasMany fields when the resource is in legacy mode`);
+                  }
+                })(context.legacy) : {};
+                if (schema._kind('@legacy', 'hasMany').notify(context.store, proxy, resourceKey, field)) {
+                  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                    if (!test) {
+                      throw new Error(`Expected options to exist on relationship meta`);
+                    }
+                  })(field.options) : {};
+                  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+                    if (!test) {
+                      throw new Error(`Expected async to exist on relationship meta options`);
+                    }
+                  })('async' in field.options) : {};
+                  if (field.options.async) {
+                    const signal = signals.get(key);
+                    if (signal) {
+                      notifyInternalSignal(signal);
+                    }
+                  }
+                }
+              } else if (field.kind === 'collection') ;
+            }
+          }
+          break;
+      }
+    });
+    const proxy = new Proxy(this, {
+      ownKeys() {
+        const identityKey = identityField?.name;
+        const keys = Array.from(fields.keys());
+        if (identityKey) {
+          keys.unshift(identityKey);
+        }
+        return keys;
+      },
+      has(target, prop) {
+        if (prop === Destroy || prop === Checkout) {
+          return true;
+        }
+        return fields.has(prop);
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        const schemaForField = prop === identityField?.name ? identityField : fields.get(prop);
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`No field named ${String(prop)} on ${resourceKey.type}`);
+          }
+        })(schemaForField) : {};
+        if (isNonEnumerableProp(prop)) {
+          return {
+            writable: false,
+            enumerable: false,
+            configurable: true
+          };
+        }
+        switch (schemaForField.kind) {
+          case 'derived':
+            return {
+              writable: false,
+              enumerable: true,
+              configurable: true
+            };
+          case '@id':
+            return {
+              writable: resourceKey.id === null,
+              enumerable: true,
+              configurable: true
+            };
+          case '@local':
+          case 'field':
+          case 'attribute':
+          case 'resource':
+          case 'alias':
+          case 'belongsTo':
+          case 'hasMany':
+          case 'collection':
+          case 'schema-array':
+          case 'array':
+          case 'schema-object':
+          case 'object':
+            return {
+              writable: context.editable,
+              enumerable: true,
+              configurable: true
+            };
+          default:
+            return {
+              writable: false,
+              enumerable: false,
+              configurable: false
+            };
+        }
+      },
+      get(target, prop, receiver) {
+        if (RecordSymbols.has(prop)) {
+          if (prop === Destroy) {
+            return () => _DESTROY(receiver);
+          }
+          if (prop === Checkout) {
+            return () => Promise.resolve(_CHECKOUT(receiver));
+          }
+          return target[prop];
+        }
+        if (prop === Signals) {
+          return signals;
+        }
+
+        // TODO make this a symbol
+        if (prop === '___notifications') {
+          return target.___notifications;
+        }
+
+        // ReactiveResource reserves use of keys that begin with these characters
+        // for its own usage.
+        // _, @, $, *
+
+        const maybeField = prop === identityField?.name ? identityField : fields.get(prop);
+        if (!maybeField) {
+          if (IgnoredGlobalFields.has(prop)) {
+            return undefined;
+          }
+
+          /////////////////////////////////////////////////////////////
+          //// Note these bound function behaviors are essentially ////
+          //// built-in but overrideable derivations.              ////
+          ////                                                     ////
+          //// The bar for this has to be "basic expectations of   ////
+          ///  an object" – very, very high                        ////
+          /////////////////////////////////////////////////////////////
+
+          if (prop === Symbol.toStringTag || prop === 'toString') {
+            let fn = BoundFns.get('toString');
+            if (!fn) {
+              fn = function () {
+                entangleSignal(signals, receiver, '@identity', null);
+                return `Record<${resourceKey.type}:${resourceKey.id} (${resourceKey.lid})>`;
+              };
+              BoundFns.set(prop, fn);
+            }
+            return fn;
+          }
+          if (prop === 'toHTML') {
+            let fn = BoundFns.get('toHTML');
+            if (!fn) {
+              fn = function () {
+                entangleSignal(signals, receiver, '@identity', null);
+                return `<span>Record<${resourceKey.type}:${resourceKey.id} (${resourceKey.lid})></span>`;
+              };
+              BoundFns.set(prop, fn);
+            }
+            return fn;
+          }
+          if (prop === 'toJSON') {
+            let fn = BoundFns.get('toJSON');
+            if (!fn) {
+              fn = function () {
+                const json = {};
+                for (const key in receiver) {
+                  json[key] = receiver[key];
+                }
+                return json;
+              };
+              BoundFns.set(prop, fn);
+            }
+            return fn;
+          }
+          if (prop === Symbol.toPrimitive) return () => null;
+          if (prop === Symbol.iterator) {
+            let fn = BoundFns.get(Symbol.iterator);
+            if (!fn) {
+              fn = function* () {
+                for (const key in receiver) {
+                  yield [key, receiver[key]];
+                }
+              };
+              BoundFns.set(Symbol.iterator, fn);
+            }
+            return fn;
+          }
+          if (prop === 'constructor') {
+            return ReactiveResource;
+          }
+          if (isExtensionProp(extensions, prop)) {
+            return performObjectExtensionGet(receiver, extensions, signals, prop);
+          }
+
+          // too many things check for random symbols
+          if (typeof prop === 'symbol') return undefined;
+          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (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 => {
+          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)) : {};
+        /**
+         * Prop Array is the path from a resource to the field including
+         * intermediate "links" on arrays,objects,schema-arrays and schema-objects.
+         *
+         * E.g. in the following
+         *
+         * ```
+         * const user = {
+         *   addresses: [{
+         *     street: 'Sunset Blvd',
+         *     zip: 90210
+         *   }]
+         * }
+         * ```
+         *
+         * The propArray for "street" is ['addresses', 0, 'street']
+         *
+         * Prop Array follows the `cache` path to the value, not the ui path.
+         * Thus, if `addresses` has a sourceKey of `user_addresses` and
+         * `zip` has a sourceKey of `zip_code` then the propArray for "zip" is
+         * ['user_addresses', 0, 'zip_code']
+         */
+        const propArray = context.path?.slice() ?? [];
+        // we use the field.name instead of prop here because we want to use the cache-path not
+        // the record path.
+        // SAFETY: we lie as string here because if we were to get null
+        // we would be in a field kind that won't use the propArray below.
+        const fieldCacheKey = getFieldCacheKey(field);
+        propArray.push(fieldCacheKey);
+        switch (field.kind) {
+          case '@id':
+          case '@hash':
+          case '@local':
+          case 'derived':
+          case 'field':
+          case 'attribute':
+          case 'schema-array':
+          case 'array':
+          case 'schema-object':
+          case 'object':
+          case 'resource':
+          case 'belongsTo':
+          case 'hasMany':
+          case 'collection':
+            return DefaultMode[field.kind].get({
+              store: context.store,
+              resourceKey: resourceKey,
+              modeName: context.modeName,
+              legacy: context.legacy,
+              editable: context.editable,
+              path: propArray,
+              field: field,
+              record: receiver,
+              signals,
+              value: null
+            });
+          default:
+            assertNeverField(resourceKey, field, propArray);
+        }
+      },
+      set(target, prop, value, receiver) {
+        // the only "editable" prop as it is currently a proxy for "isDestroyed"
+        if (prop === '___notifications') {
+          target[prop] = value;
+          return true;
+        }
+        if (!context.editable) {
+          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+            {
+              throw new Error(`Cannot set ${String(prop)} on ${context.path !== null ? context.value : resourceKey.type} because the record is not editable`);
+            }
+          })() : {};
+          return false;
+        }
+        const maybeField = prop === identityField?.name ? identityField : fields.get(prop);
+        if (!maybeField) {
+          const type = context.path !== null ? context.value : resourceKey.type;
+          if (isExtensionProp(extensions, prop)) {
+            return performExtensionSet(receiver, extensions, signals, prop, value);
+          }
+          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (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 => {
+          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)) : {};
+        /**
+         * Prop Array is the path from a resource to the field including
+         * intermediate "links" on arrays,objects,schema-arrays and schema-objects.
+         *
+         * E.g. in the following
+         *
+         * ```
+         * const user = {
+         *   addresses: [{
+         *     street: 'Sunset Blvd',
+         *     zip: 90210
+         *   }]
+         * }
+         * ```
+         *
+         * The propArray for "street" is ['addresses', 0, 'street']
+         *
+         * Prop Array follows the `cache` path to the value, not the ui path.
+         * Thus, if `addresses` has a sourceKey of `user_addresses` and
+         * `zip` has a sourceKey of `zip_code` then the propArray for "zip" is
+         * ['user_addresses', 0, 'zip_code']
+         */
+        const propArray = context.path?.slice() ?? [];
+        // we use the field.name instead of prop here because we want to use the cache-path not
+        // the record path.
+        // SAFETY: we lie as string here because if we were to get null
+        // we would be in a field kind that won't use the propArray below.
+        const fieldCacheKey = getFieldCacheKey(field);
+        propArray.push(fieldCacheKey);
+        switch (field.kind) {
+          case '@id':
+          case '@hash':
+          case '@local':
+          case 'field':
+          case 'attribute':
+          case 'derived':
+          case 'array':
+          case 'schema-array':
+          case 'schema-object':
+          case 'object':
+          case 'resource':
+          case 'belongsTo':
+          case 'hasMany':
+          case 'collection':
+            return DefaultMode[field.kind].set({
+              store: context.store,
+              resourceKey: resourceKey,
+              modeName: context.modeName,
+              legacy: context.legacy,
+              editable: context.editable,
+              path: propArray,
+              field: field,
+              record: receiver,
+              signals,
+              value
+            });
+          default:
+            return assertNeverField(resourceKey, field, propArray);
+        }
+      }
+    });
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+      Object.defineProperty(this, '__SHOW_ME_THE_DATA_(debug mode only)__', {
+        enumerable: false,
+        configurable: true,
+        get() {
+          const data = {};
+          for (const key of fields.keys()) {
+            data[key] = proxy[key];
+          }
+          return data;
+        }
+      });
+    }
+    return proxy;
+  }
+}
+function _CHECKOUT(record) {
+  const context = record[Context];
+
+  // IF we are already the editable record, throw an error
+  if (context.editable) {
+    throw new Error(`Cannot checkout an already editable record`);
+  }
+  const editable = Editables.get(record);
+  if (editable) {
+    return editable;
+  }
+  if (context.path !== null) {
+    throw new Error(`Cannot checkout an embedded record`);
+  }
+  const editableRecord = new ReactiveResource({
+    store: context.store,
+    resourceKey: context.resourceKey,
+    modeName: context.legacy ? 'legacy' : 'polaris',
+    legacy: context.legacy,
+    editable: true,
+    path: null,
+    field: null,
+    value: null
+  });
+  setRecordIdentifier(editableRecord, recordIdentifierFor(record));
+  Editables.set(record, editableRecord);
+  return editableRecord;
+}
+function _DESTROY(record) {
+  if (record[Context].legacy) {
+    // @ts-expect-error
+    record.isDestroying = true;
+    // @ts-expect-error
+    record.isDestroyed = true;
+  } else if (!record[Context].editable) {
+    const editable = Editables.get(record);
+    if (editable) {
+      _DESTROY(editable);
+      removeRecordIdentifier(editable);
+    }
+  }
+  record[Context].store.notifications.unsubscribe(record.___notifications);
+  record.___notifications = null;
+
+  // FIXME we need a way to also unsubscribe all SchemaObjects when the primary
+  // resource is destroyed.
+}
+function assertNeverField(identifier, field, path) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    {
+      throw new Error(`Cannot use unknown field kind ${field.kind} on <${identifier.type}>.${Array.isArray(path) ? path.join('.') : path}`);
+    }
+  })() : {};
+  return false;
+}
+const TEXT_COLORS = {
+  TEXT: 'inherit',
+  notify: ['white', 'white', 'inherit', 'magenta', 'inherit'],
+  'reactive-ui': ['white', 'white', 'inherit', 'magenta', 'inherit'],
+  graph: ['white', 'white', 'inherit', 'magenta', 'inherit'],
+  request: ['white', 'white', 'inherit', 'magenta', 'inherit'],
+  cache: ['white', 'white', 'inherit', 'magenta', 'inherit']
+};
+const BG_COLORS = {
+  TEXT: 'transparent',
+  notify: ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent'],
+  'reactive-ui': ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent'],
+  graph: ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent'],
+  request: ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent'],
+  cache: ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent']
+};
+const NOTIFY_BORDER = {
+  TEXT: 0,
+  notify: [3, 2, 0, 0, 0],
+  'reactive-ui': [3, 2, 0, 0, 0],
+  graph: [3, 2, 0, 0, 0],
+  request: [3, 2, 0, 0, 0],
+  cache: [3, 2, 0, 0, 0]
+};
+const LIGHT_DARK_ALT = {
+  lightgreen: 'green',
+  green: 'lightgreen'
+};
+function badge(isLight, color, bgColor, border) {
+  return [`color: ${correctColor(isLight, color)}; background-color: ${correctColor(isLight, bgColor)}; padding: ${border}px ${2 * border}px; border-radius: ${border}px;`, `color: ${TEXT_COLORS.TEXT}; background-color: ${BG_COLORS.TEXT};`];
+}
+function colorForBucket(isLight, scope, bucket) {
+  if (scope === 'notify') {
+    return bucket === 'added' ? badge(isLight, 'lightgreen', 'transparent', 0) : bucket === 'removed' ? badge(isLight, 'red', 'transparent', 0) : badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]);
+  }
+  if (scope === 'reactive-ui') {
+    return bucket === 'created' ? badge(isLight, 'lightgreen', 'transparent', 0) : bucket === 'disconnected' ? badge(isLight, 'red', 'transparent', 0) : badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]);
+  }
+  if (scope === 'cache') {
+    return bucket === 'inserted' ? badge(isLight, 'lightgreen', 'transparent', 0) : bucket === 'removed' ? badge(isLight, 'red', 'transparent', 0) : badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]);
+  }
+  return badge(isLight, TEXT_COLORS[scope][3], BG_COLORS[scope][3], NOTIFY_BORDER[scope][3]);
+}
+function logGroup(scope, prefix, subScop1, subScop2, subScop3, subScop4) {
+  // eslint-disable-next-line no-console
+  console.groupCollapsed(..._log(scope, prefix, subScop1, subScop2, subScop3, subScop4));
+}
+function log(scope, prefix, subScop1, subScop2, subScop3, subScop4) {
+  // eslint-disable-next-line no-console
+  console.log(..._log(scope, prefix, subScop1, subScop2, subScop3, subScop4));
+}
+function correctColor(isLight, color) {
+  if (!isLight) {
+    return color;
+  }
+  return color in LIGHT_DARK_ALT ? LIGHT_DARK_ALT[color] : color;
+}
+function isLightMode() {
+  if (window?.matchMedia?.('(prefers-color-scheme: light)').matches) {
+    return true;
+  }
+  return false;
+}
+function _log(scope, prefix, subScop1, subScop2, subScop3, subScop4) {
+  const isLight = isLightMode();
+  switch (scope) {
+    case 'reactive-ui':
+    case 'notify':
+      {
+        const scopePath = prefix ? `[${prefix}] ${scope}` : scope;
+        const path = subScop4 ? `${subScop3}.${subScop4}` : subScop3;
+        return [`%c@warp%c-%cdrive%c %c${scopePath}%c %c${subScop1}%c %c${subScop2}%c %c${path}%c`, ...badge(isLight, 'lightgreen', 'transparent', 0), ...badge(isLight, 'magenta', 'transparent', 0), ...badge(isLight, TEXT_COLORS[scope][0], BG_COLORS[scope][0], NOTIFY_BORDER[scope][0]), ...badge(isLight, TEXT_COLORS[scope][1], BG_COLORS[scope][1], NOTIFY_BORDER[scope][1]), ...badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]), ...colorForBucket(isLight, scope, path)];
+      }
+    case 'cache':
+      {
+        const scopePath = prefix ? `${scope} (${prefix})` : scope;
+        return [`%c@warp%c-%cdrive%c %c${scopePath}%c %c${subScop1}%c %c${subScop2}%c %c${subScop3}%c %c${subScop4}%c`, ...badge(isLight, 'lightgreen', 'transparent', 0), ...badge(isLight, 'magenta', 'transparent', 0), ...badge(isLight, TEXT_COLORS[scope][0], BG_COLORS[scope][0], NOTIFY_BORDER[scope][0]), ...badge(isLight, TEXT_COLORS[scope][1], BG_COLORS[scope][1], NOTIFY_BORDER[scope][1]), ...badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]), ...colorForBucket(isLight, scope, subScop3), ...badge(isLight, TEXT_COLORS[scope][4], BG_COLORS[scope][4], NOTIFY_BORDER[scope][4])];
+      }
+  }
+  return [];
+}
+class CacheCapabilitiesManager {
+  constructor(_store) {
+    this._store = _store;
+    this._willNotify = false;
+    this._pendingNotifies = new Map();
+  }
+  get identifierCache() {
+    return this._store.identifierCache;
+  }
+  _scheduleNotification(identifier, key) {
+    let pending = this._pendingNotifies.get(identifier);
+    if (!pending) {
+      pending = new Set();
+      this._pendingNotifies.set(identifier, pending);
+    }
+    pending.add(key);
+    if (this._willNotify === true) {
+      return;
+    }
+    this._willNotify = true;
+    // it's possible a cache adhoc notifies us,
+    // in which case we sync flush
+    if (this._store._cbs) {
+      this._store._schedule('notify', () => this._flushNotifications());
+    } else {
+      // TODO @runspired determine if relationship mutations should schedule
+      // into join/run vs immediate flush
+      this._flushNotifications();
     }
   }
   _flushNotifications() {
@@ -1652,30 +3705,6 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA
     return this._store.schema;
   };
 }
-
-/*
- * Returns the Cache instance associated with a given
- * Model or Identifier
- */
-
-const CacheForIdentifierCache = getOrSetGlobal('CacheForIdentifierCache', new Map());
-function setCacheFor(identifier, cache) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Illegal set of identifier`);
-    }
-  })(!CacheForIdentifierCache.has(identifier) || CacheForIdentifierCache.get(identifier) === cache) : {};
-  CacheForIdentifierCache.set(identifier, cache);
-}
-function removeRecordDataFor(identifier) {
-  CacheForIdentifierCache.delete(identifier);
-}
-function peekCache(instance) {
-  if (CacheForIdentifierCache.has(instance)) {
-    return CacheForIdentifierCache.get(instance);
-  }
-  return null;
-}
 function isDestroyable(record) {
   return Boolean(record && typeof record === 'object' && typeof record.destroy === 'function');
 }
@@ -1728,20 +3757,28 @@ 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`);
+    }
+  }
+  RecordCache.delete(record);
+}
 const StoreMap = getOrSetGlobal('StoreMap', new Map());
 
 /**
  * We may eventually make this public, but its likely better for this to be killed off
  * @internal
  */
-function storeFor(record) {
+function storeFor(record, ignoreMissing) {
   const store = StoreMap.get(record);
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (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.`);
     }
-  })(store) : {};
-  return store;
+  })(ignoreMissing || store) : {};
+  return store ?? null;
 }
 class InstanceCache {
   constructor(store) {
@@ -1812,32 +3849,10 @@ class InstanceCache {
     }
     return doc;
   }
-  getRecord(identifier, properties) {
+  getRecord(identifier) {
     let record = this.__instances.record.get(identifier);
     if (!record) {
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-        if (!test) {
-          throw new Error(`Cannot create a new record instance while the store is being destroyed`);
-        }
-      })(!this.store.isDestroying && !this.store.isDestroyed) : {};
-      const cache = this.store.cache;
-      setCacheFor(identifier, cache);
-      record = this.store.instantiateRecord(identifier, properties || {});
-      setRecordIdentifier(record, identifier);
-      setCacheFor(record, cache);
-      StoreMap.set(record, this.store);
-      this.__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
-          console.log({
-            properties
-          });
-          // eslint-disable-next-line no-console
-          console.groupEnd();
-        }
-      }
+      record = _createRecord(this, identifier, {});
     }
     return record;
   }
@@ -1871,7 +3886,7 @@ class InstanceCache {
     })(!isDestroyable(record) || record.isDestroyed || record.isDestroying) : {};
     this.store._graph?.remove(identifier);
     this.store.identifierCache.forgetRecordIdentifier(identifier);
-    removeRecordDataFor(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) {
@@ -1908,7 +3923,6 @@ class InstanceCache {
         this.__instances.record.delete(identifier);
         StoreMap.delete(record);
         RecordCache.delete(record);
-        removeRecordDataFor(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
@@ -1918,7 +3932,7 @@ class InstanceCache {
       }
       if (cache) {
         cache.unloadRecord(identifier);
-        removeRecordDataFor(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
@@ -2018,10 +4032,46 @@ class InstanceCache {
     this.store.notifications.notify(identifier, 'identity');
   }
 }
+function getNewRecord(instances, identifier, properties) {
+  let record = instances.__instances.record.get(identifier);
+  if (!record) {
+    record = _createRecord(instances, identifier, properties);
+    if (record instanceof ReactiveResource && instances.store.schema.resource) {
+      // this is a work around until we introduce a new async createRecord API
+      const schema = instances.store.schema.resource(identifier);
+      if (!schema.legacy) {
+        const editable = _CHECKOUT(record);
+        if (properties) {
+          Object.assign(editable, properties);
+        }
+        return editable;
+      }
+    }
+  }
+  return record;
+}
+function _createRecord(instances, identifier, properties) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Cannot create a new record instance while the store is being destroyed`);
+    }
+  })(!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
+      console.groupEnd();
+    }
+  }
+  return record;
+}
 function _clearCaches() {
   RecordCache.clear();
   StoreMap.clear();
-  CacheForIdentifierCache.clear();
 }
 
 /**
@@ -2828,142 +4878,6 @@ class NotificationManager {
     this._cache.clear();
   }
 }
-function isExtensionProp(extensions, prop) {
-  return Boolean(extensions && typeof prop !== 'number' && extensions.has(prop));
-}
-function performObjectExtensionGet(receiver, extensions, signals, prop) {
-  const desc = extensions.get(prop);
-  switch (desc.kind) {
-    case 'method':
-      {
-        return desc.fn;
-      }
-    case 'readonly-value':
-      {
-        return desc.value;
-      }
-    case 'mutable-value':
-      {
-        const signal = getOrCreateInternalSignal(signals, receiver, prop, desc.value);
-        // we don't consume this signal, since its not a true local.
-        return signal.value;
-      }
-    case 'readonly-field':
-    case 'mutable-field':
-      {
-        return desc.get.call(receiver);
-      }
-    case 'writeonly-field':
-      {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          {
-            throw new Error(`Cannot get extended field ${String(prop)} as its definition has only a setter`);
-          }
-        })() : {};
-        return undefined;
-      }
-    default:
-      {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          {
-            throw new Error(`Unhandled extension kind ${desc.kind}`);
-          }
-        })() : {};
-        return undefined;
-      }
-  }
-}
-function performExtensionSet(receiver, extensions, signals, prop, value) {
-  const desc = extensions.get(prop);
-  switch (desc.kind) {
-    case 'method':
-    case 'readonly-value':
-    case 'readonly-field':
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-        {
-          throw new Error(`Cannot set extension field ${String(prop)} as it is a ${desc.kind}`);
-        }
-      })() : {};
-      return false;
-    case 'mutable-value':
-      {
-        const signal = getOrCreateInternalSignal(signals, receiver, prop, desc.value);
-        if (signal.value !== value) {
-          // we don't notify this signal, since its not a true local.
-          signal.value = value;
-        }
-        return true;
-      }
-    case 'writeonly-field':
-    case 'mutable-field':
-      {
-        desc.set.call(receiver, value);
-        return true;
-      }
-    default:
-      {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          {
-            throw new Error(`Unhandled extension kind ${desc.kind}`);
-          }
-        })() : {};
-        return false;
-      }
-  }
-}
-function performArrayExtensionGet(receiver, extensions, signals, prop, _SIGNAL, boundFns, transaction) {
-  const desc = extensions.get(prop);
-  switch (desc.kind) {
-    case 'method':
-      {
-        let fn = boundFns.get(prop);
-        if (fn === undefined) {
-          fn = function () {
-            consumeInternalSignal(_SIGNAL);
-            transaction(true);
-            const result = Reflect.apply(desc.fn, receiver, arguments);
-            transaction(false);
-            return result;
-          };
-          boundFns.set(prop, fn);
-        }
-        return fn;
-      }
-    case 'mutable-field':
-    case 'readonly-field':
-      {
-        return desc.get.call(receiver);
-      }
-    case 'readonly-value':
-      {
-        return desc.value;
-      }
-    case 'mutable-value':
-      {
-        const signal = getOrCreateInternalSignal(signals, receiver, prop, desc.value);
-        // we don't consume this signal, since its not a true local.
-        return signal.value;
-      }
-    case 'writeonly-field':
-      {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          {
-            throw new Error(`Cannot get extended field ${String(prop)} as its definition has only a setter`);
-          }
-        })() : {};
-        return undefined;
-      }
-    default:
-      {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          {
-            throw new Error(`Unhandled extension kind ${desc.kind}`);
-          }
-        })() : {};
-        return undefined;
-      }
-  }
-}
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /*
@@ -3552,6 +5466,15 @@ class RecordArrayManager {
       }
     });
     this._subscription = this.store.notifications.subscribe('resource', (identifier, type) => {
+      const schema = this.store.schema.resource?.(identifier);
+      // If we are a polaris mode schema
+      // and we are in the `isNew` state, we are kept hidden from
+      // record arrays.
+      if (schema && (!('legacy' in schema) || !schema.legacy)) {
+        if (this.store.cache.isNew(identifier)) {
+          return;
+        }
+      }
       if (type === 'added') {
         this._visibilitySet.set(identifier, true);
         this.identifierAdded(identifier);
@@ -4618,30 +6541,61 @@ class Store extends BaseClass {
   }
 
   /**
-    Create a new record in the current store. The properties passed
-    to this method are set on the newly created record.
-     To create a new instance of a `Post`:
+    Creates a new record in the current store.
+     > [!CAUTION]
+    > This should not be used to mock records or to create
+    > a record representing data that could be fetched from
+    > the API.
+     The properties passed to this method are set on
+    the newly created record.
+     For instance: to create a new `post`:
      ```js
     store.createRecord('post', {
-      title: 'Ember is awesome!'
+      title: 'WarpDrive is Stellar!'
     });
     ```
-     To create a new instance of a `Post` that has a relationship with a `User` record:
+     Relationships can be set during create. For instance,
+    to create a new `post` that has an existing user as
+    it's author:
      ```js
-    let user = this.store.peekRecord('user', '1');
-    store.createRecord('post', {
-      title: 'Ember is awesome!',
+    const user = store.peekRecord('user', '1');
+     store.createRecord('post', {
+      title: 'WarpDrive is Stellar!',
       user: user
     });
+    ```
+     ### lid handling
+     All new records are assigned an `lid` that can be used to handle
+    transactional saves of multiple records, or to link the data to
+    other data in scenarios involving eventual-consistency or remote
+    syncing.
+     ```ts
+    const post = store.createRecord('post', {
+      title: 'WarpDrive is Stellar!'
+    });
+    const { lid } = recordIdentifierFor(post);
+    ```
+     The `lid` defaults to a uuidv4 string.
+     In order to support receiving knowledge about unpersisted creates
+    from other sources (say a different tab in the same web-browser),
+    createRecord allows for the `lid` to be provided as part of an
+    optional third argument. **If this lid already exists in the store
+    an error will be thrown.**
+     ```ts
+    const post = store.createRecord(
+      'post',
+      { title: 'WarpDrive is Stellar!' },
+      { lid: '4d47bb88-931f-496e-986d-c4888cef7373' }
+    );
     ```
      @public
-    @param {String} type the name of the resource
-    @param {Object} inputProperties a hash of properties to set on the
+    @param type the name of the resource
+    @param inputProperties a hash of properties to set on the
       newly created record.
-    @return {Model} record
+    @return a record in the "isNew" state
   */
 
-  createRecord(type, inputProperties) {
+  createRecord(type, inputProperties, context) {
     if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       assertDestroyingStore(this, 'createRecord');
     }
@@ -4695,11 +6649,22 @@ class Store extends BaseClass {
           }
         })(!identifier) : {};
       }
+      if (context?.lid) {
+        const identifier = this.identifierCache.peekRecordIdentifier({
+          lid: context?.lid
+        });
+        resource.lid = context.lid;
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          if (!test) {
+            throw new Error(`The lid ${context.lid} has already been used with another '${identifier?.type}' record.`);
+          }
+        })(!identifier) : {};
+      }
       const identifier = this.identifierCache.createIdentifierForNewRecord(resource);
       const cache = this.cache;
       const createOptions = normalizeProperties(this, identifier, properties);
       const resultProps = cache.clientDidCreate(identifier, createOptions);
-      record = this._instanceCache.getRecord(identifier, resultProps);
+      record = getNewRecord(this._instanceCache, identifier, resultProps);
     });
     return record;
   }
@@ -5890,7 +7855,7 @@ if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_REQUES
       if (!test) {
         throw new Error(`Unable to initiate save for a record in a disconnected state`);
       }
-    })(storeFor(record)) : {};
+    })(storeFor(record, true)) : {};
     const identifier = recordIdentifierFor(record);
     const cache = this.cache;
     if (!identifier) {
@@ -5936,6 +7901,341 @@ function upgradeInstanceCaches(cache) {
   }
   return withReferences;
 }
+const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);
+function calcShouldFetch(store, request, hasCachedValue, identifier) {
+  const {
+    cacheOptions
+  } = request;
+  return request.op && MUTATION_OPS.has(request.op) || cacheOptions?.reload || !hasCachedValue || (store.lifetimes && identifier ? store.lifetimes.isHardExpired(identifier, store) : false);
+}
+function calcShouldBackgroundFetch(store, request, willFetch, identifier) {
+  const {
+    cacheOptions
+  } = request;
+  return cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier, store) : false);
+}
+function isMutation(request) {
+  return Boolean(request.op && MUTATION_OPS.has(request.op));
+}
+function isCacheAffecting(document) {
+  if (!isMutation(document.request)) {
+    return true;
+  }
+  // a mutation combined with a 204 has no cache impact when no known records were involved
+  // a createRecord with a 201 with an empty response and no known records should similarly
+  // have no cache impact
+
+  if (document.request.op === 'createRecord' && document.response?.status === 201) {
+    return document.content ? Object.keys(document.content).length > 0 : false;
+  }
+  return document.response?.status !== 204;
+}
+function isAggregateError(error) {
+  return error instanceof AggregateError || error.name === 'AggregateError' && Array.isArray(error.errors);
+}
+// TODO @runspired, consider if we should deep freeze errors (potentially only in debug) vs cloning them
+function cloneError(error) {
+  const isAggregate = isAggregateError(error);
+  const cloned = isAggregate ? new AggregateError(structuredClone(error.errors), error.message) : new Error(error.message);
+  cloned.stack = error.stack;
+  cloned.error = error.error;
+
+  // copy over enumerable properties
+  Object.assign(cloned, error);
+  return cloned;
+}
+function getPriority(identifier, deduped, priority) {
+  if (identifier) {
+    const existing = deduped.get(identifier);
+    if (existing) {
+      return existing.priority;
+    }
+  }
+  return priority;
+}
+
+/**
+ * A CacheHandler that adds support for using an WarpDrive Cache with a RequestManager.
+ *
+ * This handler will only run when a request has supplied a `store` instance. Requests
+ * issued by the store via `store.request()` will automatically have the `store` instance
+ * attached to the request.
+ *
+ * ```ts
+ * requestManager.request({
+ *   store: store,
+ *   url: '/api/posts',
+ *   method: 'GET'
+ * });
+ * ```
+ *
+ * When this handler elects to handle a request, it will return the raw `StructuredDocument`
+ * unless the request has `[EnableHydration]` set to `true`. In this case, the handler will
+ * return a `Document` instance that will automatically update the UI when the cache is updated
+ * in the future and will hydrate any identifiers in the StructuredDocument into Record instances.
+ *
+ * When issuing a request via the store, [EnableHydration] is automatically set to `true`. This
+ * means that if desired you can issue requests that utilize the cache without needing to also
+ * utilize Record instances if desired.
+ *
+ * Said differently, you could elect to issue all requests via a RequestManager, without ever using
+ * the store directly, by setting [EnableHydration] to `true` and providing a store instance. Not
+ * necessarily the most useful thing, but the decoupled nature of the RequestManager and incremental-feature
+ * approach of WarpDrive allows for this flexibility.
+ *
+ * ```ts
+ * import { EnableHydration } from '@warp-drive/core/types/request';
+ *
+ * requestManager.request({
+ *   store: store,
+ *   url: '/api/posts',
+ *   method: 'GET',
+ *   [EnableHydration]: true
+ * });
+ *
+ */
+const CacheHandler = {
+  request(context, next) {
+    // if we have no cache or no cache-key skip cache handling
+    if (!context.request.store || context.request.cacheOptions?.[SkipCache]) {
+      return next(context.request);
+    }
+    const {
+      store
+    } = context.request;
+    const identifier = store.identifierCache.getOrCreateDocumentIdentifier(context.request);
+    if (identifier) {
+      context.setIdentifier(identifier);
+    }
+
+    // used to dedupe existing requests that match
+    const DEDUPE = store.requestManager._deduped;
+    const activeRequest = identifier && DEDUPE.get(identifier);
+    const peeked = identifier ? store.cache.peekRequest(identifier) : null;
+
+    // determine if we should skip cache
+    if (calcShouldFetch(store, context.request, !!peeked, identifier)) {
+      if (activeRequest) {
+        activeRequest.priority = {
+          blocking: true
+        };
+        return activeRequest.promise;
+      }
+      let promise = fetchContentAndHydrate(next, context, identifier, {
+        blocking: true
+      });
+      if (identifier) {
+        promise = promise.finally(() => {
+          DEDUPE.delete(identifier);
+          store.notifications.notify(identifier, 'state');
+        });
+        DEDUPE.set(identifier, {
+          priority: {
+            blocking: true
+          },
+          promise
+        });
+        store.notifications.notify(identifier, 'state');
+      }
+      return promise;
+    }
+
+    // if we have not skipped cache, determine if we should update behind the scenes
+    if (calcShouldBackgroundFetch(store, context.request, false, identifier)) {
+      let promise = activeRequest?.promise || fetchContentAndHydrate(next, context, identifier, {
+        blocking: false
+      });
+      if (identifier && !activeRequest) {
+        promise = promise.finally(() => {
+          DEDUPE.delete(identifier);
+          store.notifications.notify(identifier, 'state');
+        });
+        DEDUPE.set(identifier, {
+          priority: {
+            blocking: false
+          },
+          promise
+        });
+        store.notifications.notify(identifier, 'state');
+      }
+      store.requestManager._pending.set(context.id, promise);
+    }
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected a peeked request to be present`);
+      }
+    })(peeked) : {};
+    const shouldHydrate = context.request[EnableHydration] || false;
+    context.setResponse(peeked.response);
+    if ('error' in peeked) {
+      const content = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
+        shouldHydrate,
+        identifier
+      }, peeked.content) : peeked.content;
+      const newError = cloneError(peeked);
+      newError.content = content;
+      throw newError;
+    }
+    const result = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
+      shouldHydrate,
+      identifier
+    }, peeked.content) : peeked.content;
+    return result;
+  }
+};
+function maybeUpdateUiObjects(store, request, options, document) {
+  const {
+    identifier
+  } = options;
+  if (!document || !options.shouldHydrate) {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`The CacheHandler expected response content but none was found`);
+      }
+    })(!options.shouldHydrate) : {};
+    return document ?? null;
+  }
+  if (identifier) {
+    return store._instanceCache.getDocument(identifier);
+  }
+
+  // if we don't have an identifier, we give the document
+  // its own local cache
+  return new ReactiveDocument(store, null, {
+    request,
+    document
+  });
+}
+function updateCacheForSuccess(store, request, options, document) {
+  let response = null;
+  if (isMutation(request)) {
+    const record = request.data?.record || request.records?.[0];
+    if (record) {
+      response = store.cache.didCommit(record, document);
+
+      // a mutation combined with a 204 has no cache impact when no known records were involved
+      // a createRecord with a 201 with an empty response and no known records should similarly
+      // have no cache impact
+    } else if (isCacheAffecting(document)) {
+      response = store.cache.put(document);
+    }
+  } else {
+    response = store.cache.put(document);
+  }
+  return maybeUpdateUiObjects(store, request, options, response);
+}
+function handleFetchSuccess(store, context, options, document) {
+  const {
+    request
+  } = context;
+  store.requestManager._pending.delete(context.id);
+  store._enableAsyncFlush = true;
+  let response;
+  store._join(() => {
+    response = updateCacheForSuccess(store, request, options, document);
+  });
+  store._enableAsyncFlush = null;
+  if (store.lifetimes?.didRequest) {
+    store.lifetimes.didRequest(context.request, document.response, options.identifier, store);
+  }
+  const finalPriority = getPriority(options.identifier, store.requestManager._deduped, options.priority);
+  if (finalPriority.blocking) {
+    return response;
+  } else {
+    store.notifications._flush();
+  }
+}
+function updateCacheForError(store, context, options, error) {
+  let response;
+  if (isMutation(context.request)) {
+    // TODO similar to didCommit we should spec this to be similar to cache.put for handling full response
+    // currently we let the response remain undefiend.
+    const errors = error && error.content && typeof error.content === 'object' && 'errors' in error.content && Array.isArray(error.content.errors) ? error.content.errors : undefined;
+    const record = context.request.data?.record || context.request.records?.[0];
+    store.cache.commitWasRejected(record, errors);
+  } else {
+    response = store.cache.put(error);
+    return maybeUpdateUiObjects(store, context.request, options, response);
+  }
+}
+function handleFetchError(store, context, options, error) {
+  store.requestManager._pending.delete(context.id);
+  if (context.request.signal?.aborted) {
+    throw error;
+  }
+  store._enableAsyncFlush = true;
+  let response;
+  store._join(() => {
+    response = updateCacheForError(store, context, options, error);
+  });
+  store._enableAsyncFlush = null;
+  if (options.identifier && store.lifetimes?.didRequest) {
+    store.lifetimes.didRequest(context.request, error.response, options.identifier, store);
+  }
+  if (isMutation(context.request)) {
+    throw error;
+  }
+  const finalPriority = getPriority(options.identifier, store.requestManager._deduped, options.priority);
+  if (finalPriority.blocking) {
+    const newError = cloneError(error);
+    newError.content = response;
+    throw newError;
+  } else {
+    store.notifications._flush();
+  }
+}
+function fetchContentAndHydrate(next, context, identifier, priority) {
+  const {
+    store
+  } = context.request;
+  const shouldHydrate = context.request[EnableHydration] || false;
+  const options = {
+    shouldHydrate,
+    identifier,
+    priority
+  };
+  let isMut = false;
+  if (isMutation(context.request)) {
+    isMut = true;
+    // TODO should we handle multiple records in request.records by iteratively calling willCommit for each
+    const record = context.request.data?.record || context.request.records?.[0];
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected to receive a list of records included in the ${context.request.op} request`);
+      }
+    })(record || !shouldHydrate) : {};
+    if (record) {
+      store.cache.willCommit(record, context);
+    }
+  }
+  if (store.lifetimes?.willRequest) {
+    store.lifetimes.willRequest(context.request, identifier, store);
+  }
+  const promise = next(context.request).then(document => {
+    return handleFetchSuccess(store, context, options, document);
+  }, error => {
+    return handleFetchError(store, context, options, error);
+  });
+  if (!isMut) {
+    return promise;
+  }
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected a mutation`);
+    }
+  })(isMutation(context.request)) : {};
+
+  // for mutations we need to enqueue the promise with the requestStateService
+  // TODO should we enque a request per record in records?
+  const record = context.request.data?.record || context.request.records?.[0];
+  return store._requestCache._enqueue(promise, {
+    data: [{
+      op: 'saveRecord',
+      recordIdentifier: record,
+      options: undefined
+    }]
+  });
+}
 function isNonEmptyString(str) {
   return Boolean(str && typeof str === 'string');
 }
@@ -7641,4 +9941,4 @@ function getRequestState(future) {
   }
   return state;
 }
-export { defineNonEnumerableSignal as A, Signals as B, Collection as C, DISPOSE as D, peekInternalSignal as E, withSignalStore as F, notifyInternalSignal as G, consumeInternalSignal as H, IdentifierArray as I, getOrCreateInternalSignal as J, ReactiveDocument as K, setIdentifierGenerationMethod as L, MUTATE as M, setIdentifierUpdateMethod as N, setIdentifierForgetMethod as O, setIdentifierResetMethod as P, setKeyInfoForResource as Q, RecordArrayManager as R, Store as S, isExtensionProp as T, performExtensionSet as U, performArrayExtensionGet as V, performObjectExtensionGet as W, _clearCaches as _, isDocumentIdentifier as a, coerceId as b, constructResource as c, SOURCE as d, ensureStringId as e, fastPush as f, removeRecordDataFor as g, setRecordIdentifier as h, isStableIdentifier as i, StoreMap as j, setCacheFor as k, RelatedCollection as l, log as m, normalizeModelName as n, logGroup as o, peekCache as p, getPromiseState as q, recordIdentifierFor as r, storeFor as s, createRequestSubscription as t, getRequestState as u, memoized as v, gate as w, entangleSignal as x, defineSignal as y, defineGate as z };
+export { peekInternalSignal as A, withSignalStore as B, CacheHandler as C, DISPOSE as D, notifyInternalSignal as E, consumeInternalSignal as F, getOrCreateInternalSignal as G, ReactiveResource as H, IdentifierArray as I, isNonIdentityCacheableField as J, getFieldCacheKeyStrict as K, setIdentifierGenerationMethod as L, MUTATE as M, setIdentifierUpdateMethod as N, setIdentifierForgetMethod as O, setIdentifierResetMethod as P, setKeyInfoForResource as Q, RecordArrayManager as R, Store as S, _clearCaches as _, isDocumentIdentifier as a, coerceId as b, constructResource as c, Collection as d, ensureStringId as e, SOURCE as f, fastPush as g, setRecordIdentifier as h, isStableIdentifier as i, StoreMap as j, RelatedCollection as k, log as l, logGroup as m, normalizeModelName as n, getPromiseState as o, createRequestSubscription as p, getRequestState as q, recordIdentifierFor as r, storeFor as s, memoized as t, gate as u, entangleSignal as v, defineSignal as w, defineGate as x, defineNonEnumerableSignal as y, Signals as z };